package com.sg.service.biz.component.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.dto.TreeNode;
import com.sg.common.exception.Assert;
import com.sg.common.exception.BizException;
import com.sg.common.util.RedisUtil;
import com.sg.dto.biz.component.common.*;
import com.sg.dto.biz.component.req.*;
import com.sg.dto.biz.component.res.*;
import com.sg.service.base.component.MOmsConfApplexRelService;
import com.sg.service.base.component.MOmsSchemeOpenRecordService;
import com.sg.service.base.component.MOmsUnstructuredDataService;
import com.sg.service.biz.component.ConfSchemeService;
import com.sg.service.biz.component.InterfaceModeService;
import com.sg.service.biz.component.nb.NbInterfaceMode;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class InterfaceModeServiceImpl implements InterfaceModeService {
    @Resource
    private RedisUtil redisUtil;
    //@Resource
    //private MCustomFieldsService mCustomFieldsService;
    @Resource
    private NbInterfaceMode nbInterfaceMode;
    @Resource
    private MOmsSchemeOpenRecordService mOmsSchemeOpenRecordService;
    @Resource
    private MOmsUnstructuredDataService mOmsUnstructuredDataService;
    @Resource
    private MOmsConfApplexRelService mOmsConfApplexRelService;
    @Resource
    private ConfSchemeService confSchemeService;
//@Resource
    //private MOmsCycleService mOmsCycleService;
//@Resource
    //private MCustomFields4Service mCustomFields4Service;
//@Resource
    //private MCustomFields5Service mCustomFields5Service;
//@Resource
    //private MMmmShellService mMmmShellService;
//@Resource
    //private MSystemPersonInfoService mSystemPersonInfoService;
//@Resource
    //private MOmsBasicInstanceUnstructuredRelationshipService mOmsBasicInstanceUnstructuredRelationshipService;
//@Resource
    //private MCustomFields2Service mCustomFields2Service;
//@Resource
    //private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
//@Resource
    //private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
//@Resource
// private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
//@Resource
    //private MCustomFields3Service mCustomFields3Service;

    /**
     * D2执行数据集相减得结果(公共)[4637]
     * gen by moon at 10/1/2022, 11:28:37 PM
     */
    @Trace(operationName = "D2执行数据集相减得结果(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetSubtractResultsComRespDto implementDataSetSubtractResultsCom(ImplementDataSetSubtractResultsComReqDto reqDto) {


        ImplementDataSetSubtractResultsRespDto multiCollectionRemoveExistingDataRes_1 = null;
//步骤0: M2执行数据集相减得结果（特殊方法） - implementDataSetSubtractResults
        //ModelCode: multiCollectionRemoveExistingData
        ImplementDataSetSubtractResultsRespDto multiCollectionRemoveExistingDataRes = null;
        ImplementDataSetSubtractResultsReqDto multiCollectionRemoveExistingDataReq = new ImplementDataSetSubtractResultsReqDto();
        if (reqDto != null) {
            //list-field-assign
            multiCollectionRemoveExistingDataReq.setAllSingleFieldDataSetList(reqDto.getAllSingleFieldDataSetList());//sourceId:337134_1
//list-field-assign
            multiCollectionRemoveExistingDataReq.setDataSetSingleFieldPartList(reqDto.getDataSetSingleFieldPartList());//sourceId:337135_1
        }

        /*M2执行数据集相减得结果（特殊方法）[4595]  入参多个数据集。用第一个数据集（全量），排除第二、第三。。。数据集中已经存在的数据，将剩余的数据输出 */

        multiCollectionRemoveExistingDataRes = nbInterfaceMode.implementDataSetSubtractResults(multiCollectionRemoveExistingDataReq);


        multiCollectionRemoveExistingDataRes_1 = multiCollectionRemoveExistingDataRes;

        ImplementDataSetSubtractResultsComRespDto retData = new ImplementDataSetSubtractResultsComRespDto();
        if (multiCollectionRemoveExistingDataRes_1 != null) {
            //list-field-assign
            retData.setDataSetSubtractResultsList(multiCollectionRemoveExistingDataRes_1.getDataSetSubtractResultsList());//sourceId:337138_1
        }


        return retData;
    }

    /**
     * D2-执行集合去除已存在的数据服务(公共)[5111]
     * gen by moon at 12/1/2022, 1:28:43 AM
     */
    @Trace(operationName = "D2-执行集合去除已存在的数据服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCollectionRemoveExistingDataComRespDto implementCollectionRemoveExistingDataCom(ImplementCollectionRemoveExistingDataComReqDto reqDto) {


        ImplementCollectionRemoveExistingDataComRespDto collectionRemoveExistingDataRes_1 = null;
//步骤0: M2-执行集合去除已存在的数据服务(公共) - implementCollectionRemoveExistingDataCom
        //ModelCode: collectionRemoveExistingData
        ImplementCollectionRemoveExistingDataComRespDto collectionRemoveExistingDataRes = null;
        ImplementCollectionRemoveExistingDataComReqDto collectionRemoveExistingDataReq = new ImplementCollectionRemoveExistingDataComReqDto();
        if (reqDto != null) {
            collectionRemoveExistingDataReq.setAllSingleFieldDataSetList(reqDto.getAllSingleFieldDataSetList());//list-field-assign//sourceId:419613_1
            collectionRemoveExistingDataReq.setDataSetSingleFieldPartList(reqDto.getDataSetSingleFieldPartList());//list-field-assign//sourceId:419614_1
        }

        /*M2-执行集合去除已存在的数据服务(公共)[5110]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */

        collectionRemoveExistingDataRes = nbInterfaceMode.implementCollectionRemoveExistingDataCom(collectionRemoveExistingDataReq);


        collectionRemoveExistingDataRes_1 = collectionRemoveExistingDataRes;

        ImplementCollectionRemoveExistingDataComRespDto retData = new ImplementCollectionRemoveExistingDataComRespDto();
        if (collectionRemoveExistingDataRes_1 != null) {
            retData.setDataSetRemoveExistingResultsList(collectionRemoveExistingDataRes_1.getDataSetRemoveExistingResultsList());//list-field-assign//sourceId:419618_1
        }


        return retData;
    }

    /**
     * D2执行数据集记录去重(公共)[5138]
     * gen by moon at 12/2/2022, 10:21:34 PM
     */
    @Trace(operationName = "D2执行数据集记录去重(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetDuplicateRemovalComRespDto implementDataSetDuplicateRemovalCom(ImplementDataSetDuplicateRemovalComReqDto reqDto) {


        AssemblyDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes_1 = null;
//步骤0: M2执行数据集记录去重（特殊方法） - implementDataSetDuplicateRemoval
        //ModelCode: collectionRemoveDuplicateData
        AssemblyDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes = null;
        AssemblyDataSetDuplicateRemovalReqDto collectionRemoveDuplicateDataReq = new AssemblyDataSetDuplicateRemovalReqDto();
        if (reqDto != null) {
            collectionRemoveDuplicateDataReq.setDataSetDuplicateRemovalList(reqDto.getDataSetDuplicateRemovalList());//list-field-assign//sourceId:422728_1
        }

        /*M2执行数据集记录去重（特殊方法）[5137]  入参一个数据集，通过去重标识，去除数据集中重复的数据 */

        collectionRemoveDuplicateDataRes = nbInterfaceMode.assemblyDataSetDuplicateRemoval(collectionRemoveDuplicateDataReq);


        collectionRemoveDuplicateDataRes_1 = collectionRemoveDuplicateDataRes;

        ImplementDataSetDuplicateRemovalComRespDto retData = new ImplementDataSetDuplicateRemovalComRespDto();
        if (collectionRemoveDuplicateDataRes_1 != null) {
            retData.setDataSetDuplicateRemovalList(collectionRemoveDuplicateDataRes_1.getDataSetDuplicateRemovalList());//list-field-assign//sourceId:422737_1
        }


        return retData;
    }

    /**
     * D2-执行数据集去除非空值数据服务(公共)[5142]
     * gen by moon at 11/6/2022, 3:35:27 AM
     */
    @Trace(operationName = "D2-执行数据集去除非空值数据服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetRemoveUnNullDataComRespDto implementDataSetRemoveUnNullDataCom(ImplementDataSetRemoveUnNullDataComReqDto reqDto) {


        ImplementDataSetRemoveUnNullDataRespDto filterDataDelNullRecordRes_1 = null;
//步骤0: M2-执行数据集去除非空值数据 - implementDataSetRemoveUnNullData
        //ModelCode: filterDataDelNullRecord
        ImplementDataSetRemoveUnNullDataRespDto filterDataDelNullRecordRes = null;
        ImplementDataSetRemoveUnNullDataReqDto filterDataDelNullRecordReq = new ImplementDataSetRemoveUnNullDataReqDto();
        if (reqDto != null && reqDto.getDataSetRemoveNullDataList() != null && !CollectionUtil.isEmpty(reqDto.getDataSetRemoveNullDataList())) {
            filterDataDelNullRecordReq.setDataSetRemoveNullDataList(reqDto.getDataSetRemoveNullDataList().stream().map(item -> BeanUtil.toBean(item, DataSetRemoveNullDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:422822_1
        }

        /*M2-执行数据集去除非空值数据[5141]  入参数据集，数据集主键A+非主键B，将B字段不为空的数据记录过滤掉（为空的出参） */

        filterDataDelNullRecordRes = nbInterfaceMode.implementDataSetRemoveUnNullData(filterDataDelNullRecordReq);


        filterDataDelNullRecordRes_1 = filterDataDelNullRecordRes;

        ImplementDataSetRemoveUnNullDataComRespDto retData = new ImplementDataSetRemoveUnNullDataComRespDto();
        if (filterDataDelNullRecordRes_1 != null) {
            retData.setDataSetRemoveNullDataList(filterDataDelNullRecordRes_1.getDataSetRemoveNullDataList());//list-field-assign//sourceId:422825_1
        }


        return retData;
    }

    /**
     * D2执行数据集加一条记录(公共)[5161]
     * gen by moon at 11/6/2022, 11:18:21 PM
     */
    @Trace(operationName = "D2执行数据集加一条记录(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetPlusOneComRespDto implementDataSetPlusOneCom(ImplementDataSetPlusOneComReqDto reqDto) {


        DataSetPlusOneAssemblyRespDto dataSetPlusOneAssemblyRes_1 = null;
//步骤0: M执行数据集加一条记录(特殊方法) - implementDataSetPlusOne
        //ModelCode: dataSetPlusOneAssembly
        DataSetPlusOneAssemblyRespDto dataSetPlusOneAssemblyRes = null;
        DataSetPlusOneAssemblyReqDto dataSetPlusOneAssemblyReq = new DataSetPlusOneAssemblyReqDto();
        if (reqDto != null) {
            dataSetPlusOneAssemblyReq.setDataSetPlusOneList(reqDto.getDataSetPlusOneList());//list-field-assign//sourceId:424341_1
            dataSetPlusOneAssemblyReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:424342_1
        }

        /*M执行数据集加一条记录(特殊方法)[5160]  入参数据集和单记录，将单记录追加到数据集内 */
        Assert.isNull(dataSetPlusOneAssemblyReq.getCommPrimaryKey(), "D2执行数据集加一条记录(公共)-M执行数据集加一条记录(特殊方法)-通用主键ID不能为空", false);
        dataSetPlusOneAssemblyRes = nbInterfaceMode.dataSetPlusOneAssembly(dataSetPlusOneAssemblyReq);


        dataSetPlusOneAssemblyRes_1 = dataSetPlusOneAssemblyRes;

        ImplementDataSetPlusOneComRespDto retData = new ImplementDataSetPlusOneComRespDto();
        if (dataSetPlusOneAssemblyRes_1 != null) {
            retData.setDataSetPlusOneList(dataSetPlusOneAssemblyRes_1.getDataSetPlusOneList());//list-field-assign//sourceId:424346_1
        }


        return retData;
    }

    /**
     * D2执行数据集每条与单数值比较(公共)[5158]
     * gen by moon at 12/16/2022, 4:21:44 AM
     */
    @Trace(operationName = "D2执行数据集每条与单数值比较(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetEachSingleValueComparisonComRespDto implementDataSetEachSingleValueComparisonCom(ImplementDataSetEachSingleValueComparisonComReqDto reqDto) {


        ImplementDataSetEachSingleValueComparisonRespDto dataSetEachSingleValueComparisonRes_1 = null;
//步骤0: M21执行数据集每条与单数值比较(特殊方法) - implementDataSetEachSingleValueComparison
        //ModelCode: dataSetEachSingleValueComparison
        ImplementDataSetEachSingleValueComparisonRespDto dataSetEachSingleValueComparisonRes = null;
        ImplementDataSetEachSingleValueComparisonReqDto dataSetEachSingleValueComparisonReq = new ImplementDataSetEachSingleValueComparisonReqDto();
        if (reqDto != null) {
            dataSetEachSingleValueComparisonReq.setDataSetEachSingleValueComparisonList(reqDto.getDataSetEachSingleValueComparisonList());//list-field-assign//sourceId:424263_1
            dataSetEachSingleValueComparisonReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:519330_1
            dataSetEachSingleValueComparisonReq.setCalcMaxAndMin(reqDto.getCalcMaxAndMin());//SimpleFieldAssign//sourceId:424403_1
        }

        /*M21执行数据集每条与单数值比较(特殊方法)[5157]  入参数据集与单数值，用数据集中每条记录的数值与数据集外的单数值进行比较 */
        Assert.isNull(dataSetEachSingleValueComparisonReq.getCalcPara2(), "D2执行数据集每条与单数值比较(公共)-M21执行数据集每条与单数值比较(特殊方法)-计算入参2不能为空", false);
        Assert.isNull(dataSetEachSingleValueComparisonReq.getCalcMaxAndMin(), "D2执行数据集每条与单数值比较(公共)-M21执行数据集每条与单数值比较(特殊方法)-求最大最小值不能为空", false);
        dataSetEachSingleValueComparisonRes = nbInterfaceMode.implementDataSetEachSingleValueComparison(dataSetEachSingleValueComparisonReq);


        dataSetEachSingleValueComparisonRes_1 = dataSetEachSingleValueComparisonRes;

        ImplementDataSetEachSingleValueComparisonComRespDto retData = new ImplementDataSetEachSingleValueComparisonComRespDto();
        if (dataSetEachSingleValueComparisonRes_1 != null) {
            retData.setLogicalOperator(dataSetEachSingleValueComparisonRes_1.getLogicalOperator());//SimpleFieldAssign//sourceId:424268_1
        }


        return retData;
    }

    /**
     * D2执行数据集数值相加与单数值比较(公共)[5156]
     * gen by moon at 12/16/2022, 4:21:43 AM
     */
    @Trace(operationName = "D2执行数据集数值相加与单数值比较(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetSumOfSingleValueComparisonComRespDto implementDataSetSumOfSingleValueComparisonCom(ImplementDataSetSumOfSingleValueComparisonComReqDto reqDto) {


        ImplementDataSetSumOfSingleValueComparisonAssemblyRespDto dataSetSumOfSingleValueComparisonRes_1 = null;
//步骤0: M2执行数据集数值相加与单数值比较（特殊方法） - implementDataSetSumOfSingleValueComparison
        //ModelCode: dataSetSumOfSingleValueComparison
        ImplementDataSetSumOfSingleValueComparisonAssemblyRespDto dataSetSumOfSingleValueComparisonRes = null;
        ImplementDataSetSumOfSingleValueComparisonAssemblyReqDto dataSetSumOfSingleValueComparisonReq = new ImplementDataSetSumOfSingleValueComparisonAssemblyReqDto();
        if (reqDto != null) {
            dataSetSumOfSingleValueComparisonReq.setDataSetSumOfSingleValueComparisonList(reqDto.getDataSetSumOfSingleValueComparisonList());//list-field-assign//sourceId:424047_1
            dataSetSumOfSingleValueComparisonReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:519320_1
        }

        /*M2执行数据集数值相加与单数值比较（特殊方法）[5154]  入参数据集与单数值，用数据集中每条记录的数值求和与数据集外的单数值进行比较 */
        Assert.isNull(dataSetSumOfSingleValueComparisonReq.getCalcPara2(), "D2执行数据集数值相加与单数值比较(公共)-M2执行数据集数值相加与单数值比较（特殊方法）-计算入参2不能为空", false);
        dataSetSumOfSingleValueComparisonRes = nbInterfaceMode.implementDataSetSumOfSingleValueComparisonAssembly(dataSetSumOfSingleValueComparisonReq);


        dataSetSumOfSingleValueComparisonRes_1 = dataSetSumOfSingleValueComparisonRes;

        ImplementDataSetSumOfSingleValueComparisonComRespDto retData = new ImplementDataSetSumOfSingleValueComparisonComRespDto();
        if (dataSetSumOfSingleValueComparisonRes_1 != null) {
            retData.setLogicalOperator(dataSetSumOfSingleValueComparisonRes_1.getLogicalOperator());//SimpleFieldAssign//sourceId:424052_1
        }


        return retData;
    }

    /**
     * D2计算数据集最大小值记录(公共)[5162]
     * gen by moon at 2/26/2023, 1:23:51 PM
     */
    @Trace(operationName = "D2计算数据集最大小值记录(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CalculateDataBigMiniRecordComRespDto calculateDataBigMiniRecordCom(CalculateDataBigMiniRecordComReqDto reqDto) {


        CalculateDataBigMiniRecordRespDto maxOrMinOfMultipleNumRes_1 = null;
//步骤0: M2计算数据集最大小值记录（特殊方法） - calculateDataBigMiniRecord
        //ModelCode: maxOrMinOfMultipleNum
        CalculateDataBigMiniRecordRespDto maxOrMinOfMultipleNumRes = null;
        CalculateDataBigMiniRecordReqDto maxOrMinOfMultipleNumReq = new CalculateDataBigMiniRecordReqDto();
        if (reqDto != null && reqDto.getDataBigMiniRecordList() != null && !CollectionUtil.isEmpty(reqDto.getDataBigMiniRecordList())) {
            maxOrMinOfMultipleNumReq.setDataMiniRecordList(reqDto.getDataBigMiniRecordList().stream().map(item -> BeanUtil.toBean(item, DataMiniRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:424428_1
        }
        if (reqDto != null) {
            maxOrMinOfMultipleNumReq.setCalcMaxAndMin(reqDto.getCalcMaxAndMin());//SimpleFieldAssign//sourceId:424431_1
            maxOrMinOfMultipleNumReq.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:703095_1
            maxOrMinOfMultipleNumReq.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:703096_1
        }

        /*M2计算数据集最大小值记录（特殊方法）[5089]  用于求数据的最大或最小值。入参数据集+求最大或求最小标识 */
        Assert.isNull(maxOrMinOfMultipleNumReq.getCalcMaxAndMin(), "D2计算数据集最大小值记录(公共)-M2计算数据集最大小值记录（特殊方法）-求最大最小值不能为空", false);
        maxOrMinOfMultipleNumRes = nbInterfaceMode.calculateDataBigMiniRecord(maxOrMinOfMultipleNumReq);


        maxOrMinOfMultipleNumRes_1 = maxOrMinOfMultipleNumRes;

        CalculateDataBigMiniRecordComRespDto retData = new CalculateDataBigMiniRecordComRespDto();
        if (maxOrMinOfMultipleNumRes_1 != null) {
            retData.setContentID(maxOrMinOfMultipleNumRes_1.getContentID());//SimpleFieldAssign//sourceId:424434_1
            retData.setOutputNum(maxOrMinOfMultipleNumRes_1.getOutputNum());//SimpleFieldAssign//sourceId:424435_1
        }


        return retData;
    }

    /**
     * D2-计算两个数值相减服务(公共)[5168]
     * gen by moon at 11/7/2022, 11:43:17 PM
     */
    @Trace(operationName = "D2-计算两个数值相减服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CalculateSubtractOfTwoNumComRespDto calculateSubtractOfTwoNumCom(CalculateSubtractOfTwoNumComReqDto reqDto) {


        CalculateSubtractOfTwoNumComRespDto subtractionOfTwoNumRes_1 = null;
//步骤0: M2-计算两个数值相减(特殊方法) - calculateSubtractOfTwoNumCom
        //ModelCode: subtractionOfTwoNum
        CalculateSubtractOfTwoNumComRespDto subtractionOfTwoNumRes = null;
        CalculateSubtractOfTwoNumComReqDto subtractionOfTwoNumReq = new CalculateSubtractOfTwoNumComReqDto();
        if (reqDto != null) {
            subtractionOfTwoNumReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:425427_1
            subtractionOfTwoNumReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:425428_1
        }

        /*M2-计算两个数值相减(特殊方法)[5167]  用户指标数据计算，入参两个数值，计算两数之差 */

        subtractionOfTwoNumRes = nbInterfaceMode.calculateSubtractOfTwoNumCom(subtractionOfTwoNumReq);


        subtractionOfTwoNumRes_1 = subtractionOfTwoNumRes;

        CalculateSubtractOfTwoNumComRespDto retData = new CalculateSubtractOfTwoNumComRespDto();
        if (subtractionOfTwoNumRes_1 != null) {
            retData.setCalcResult(subtractionOfTwoNumRes_1.getCalcResult());//SimpleFieldAssign//sourceId:425432_1
        }


        return retData;
    }

    /**
     * D2-执行统计数据集条数服务(公共)[5166]
     * gen by moon at 1/24/2023, 3:47:45 AM
     */
    @Trace(operationName = "D2-执行统计数据集条数服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCountNumberDataSetsComRespDto implementCountNumberDataSetsCom(ImplementCountNumberDataSetsComReqDto reqDto) {


        ImplementCountNumberDataSetsComRespDto getDataCountRes_1 = null;
//步骤0: M2-执行统计数据集条数(特殊方法) - implementCountNumberDataSetsCom
        //ModelCode: getDataCount
        ImplementCountNumberDataSetsComRespDto getDataCountRes = null;
        ImplementCountNumberDataSetsComReqDto getDataCountReq = new ImplementCountNumberDataSetsComReqDto();
        if (reqDto != null && reqDto.getCountNumberDataSetsList() != null && !CollectionUtil.isEmpty(reqDto.getCountNumberDataSetsList())) {
            getDataCountReq.setCountNumberDataSetsList(reqDto.getCountNumberDataSetsList().stream().map(item -> BeanUtil.toBean(item, CountNumberDataSetsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:424943_1
        }

        /*M2-执行统计数据集条数(特殊方法)[5165]  入参一个数据集，返回数据集条数 */

        getDataCountRes = nbInterfaceMode.implementCountNumberDataSetsCom(getDataCountReq);


        getDataCountRes_1 = getDataCountRes;

        ImplementCountNumberDataSetsComRespDto retData = new ImplementCountNumberDataSetsComRespDto();
        if (getDataCountRes_1 != null) {
            retData.setOutputNum(getDataCountRes_1.getOutputNum());//SimpleFieldAssign//sourceId:424946_1
        }


        return retData;
    }

    /**
     * D2-执行计算两个数值相除服务(公共)[5176]
     * gen by moon at 11/10/2022, 11:30:41 PM
     */
    @Trace(operationName = "D2-执行计算两个数值相除服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDivisionOfTwoNumComRespDto implementDivisionOfTwoNumCom(ImplementDivisionOfTwoNumComReqDto reqDto) {


        CalculateDivisionOfTwoNumComRespDto divisionOfTwoNumRes_1 = null;
//步骤0: M2-计算两个数值相除服务(特殊方法) - calculateDivisionOfTwoNumCom
        //ModelCode: divisionOfTwoNum
        CalculateDivisionOfTwoNumComRespDto divisionOfTwoNumRes = null;
        CalculateDivisionOfTwoNumComReqDto divisionOfTwoNumReq = new CalculateDivisionOfTwoNumComReqDto();
        if (reqDto != null) {
            divisionOfTwoNumReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:427542_1
            divisionOfTwoNumReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:427543_1
        }

        /*M2-计算两个数值相除服务(特殊方法)[5175]   */

        divisionOfTwoNumRes = nbInterfaceMode.calculateDivisionOfTwoNumCom(divisionOfTwoNumReq);


        divisionOfTwoNumRes_1 = divisionOfTwoNumRes;

        ImplementDivisionOfTwoNumComRespDto retData = new ImplementDivisionOfTwoNumComRespDto();
        if (divisionOfTwoNumRes_1 != null) {
            retData.setCalcResult(divisionOfTwoNumRes_1.getCalcResult());//SimpleFieldAssign//sourceId:427547_1
        }


        return retData;
    }

    /**
     * D2-执行数据集计算完成数量(公共)[5176]
     * gen by moon at 11/12/2022, 12:34:37 AM
     */
    @Trace(operationName = "D2-执行数据集计算完成数量(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetCountAchieveNumComRespDto implementDataSetCountAchieveNumCom(ImplementDataSetCountAchieveNumComReqDto reqDto) {


        CalculateDataSetCountAchieveNumComRespDto getDataCountRes_1 = null;
//步骤0: M2-计算数据集计算完成数量(公共) - calculateDataSetCountAchieveNumCom
        //ModelCode: getDataCount
        CalculateDataSetCountAchieveNumComRespDto getDataCountRes = null;
        CalculateDataSetCountAchieveNumComReqDto getDataCountReq = new CalculateDataSetCountAchieveNumComReqDto();
        if (reqDto != null) {
            getDataCountReq.setCountAchieveNumdataSetList(reqDto.getCountAchieveNumdataSetList().stream().map(item -> BeanUtil.toBean(item, CountAchieveNumdataSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:430052_1
        }

        /*M2-计算数据集计算完成数量(公共)[5175]  入参一个数据集，返回数据集条数 */

        getDataCountRes = nbInterfaceMode.calculateDataSetCountAchieveNumCom(getDataCountReq);


        getDataCountRes_1 = getDataCountRes;

        ImplementDataSetCountAchieveNumComRespDto retData = new ImplementDataSetCountAchieveNumComRespDto();
        if (getDataCountRes_1 != null) {
            retData.setAlreadyAccomplishNum(getDataCountRes_1.getAlreadyAccomplishNum());//SimpleFieldAssign//sourceId:430054_1
            retData.setCalcCount(getDataCountRes_1.getCalcCount());//SimpleFieldAssign//sourceId:430055_1
        }


        return retData;
    }

    /**
     * D2判断条件值相等(公共)[5186]
     * gen by moon at 12/1/2022, 1:28:36 AM
     */
    @Trace(operationName = "D2判断条件值相等(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeConditionValueEqualComRespDto judgeConditionValueEqualCom(JudgeConditionValueEqualComReqDto reqDto) {


        JudgeConditionValueEqualRespDto analyzesAllParaAreEqualRes_1 = null;
//步骤0: M2判断条件值相等（特殊方法） - judgeConditionValueEqual
        //ModelCode: analyzesAllParaAreEqual
        JudgeConditionValueEqualRespDto analyzesAllParaAreEqualRes = null;
        JudgeConditionValueEqualReqDto analyzesAllParaAreEqualReq = new JudgeConditionValueEqualReqDto();
        if (reqDto != null) {
            analyzesAllParaAreEqualReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:460891_1
            analyzesAllParaAreEqualReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:460892_1
        }

        /*M2判断条件值相等（特殊方法）[5185]   */
        Assert.isNull(analyzesAllParaAreEqualReq.getCustomField1(), "D2判断条件值相等(公共)-M2判断条件值相等（特殊方法）-自定义字段1不能为空", false);
        Assert.isNull(analyzesAllParaAreEqualReq.getCustomField2(), "D2判断条件值相等(公共)-M2判断条件值相等（特殊方法）-自定义字段2不能为空", false);
        analyzesAllParaAreEqualRes = nbInterfaceMode.judgeConditionValueEqual(analyzesAllParaAreEqualReq);


        analyzesAllParaAreEqualRes_1 = analyzesAllParaAreEqualRes;

        JudgeConditionValueEqualComRespDto retData = new JudgeConditionValueEqualComRespDto();
        if (analyzesAllParaAreEqualRes_1 != null) {
            retData.setEndValue(analyzesAllParaAreEqualRes_1.getEndValue());//SimpleFieldAssign//sourceId:432676_1
        }


        return retData;
    }

    /**
     * D2判断生命周期操作(公共)[5184]
     * gen by moon at 4/21/2023, 4:56:31 PM
     */
    @Trace(operationName = "D2判断生命周期操作(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeLifecycleActionsComRespDto judgeLifecycleActionsCom(JudgeLifecycleActionsComReqDto reqDto) {


        ObtainReceiveFieldsRespDto receptionServiceRes_2 = null;
        ObtainReceiveFieldsRespDto receptionServiceRes_4 = null;
        ObtainReceiveFieldsRespDto receptionServiceRes_6 = null;
//virtualUsage M2-接收字段生命周期操作类型  21550
        //ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes = null;
        ObtainReceiveFieldsReqDto receptionServiceReq = new ObtainReceiveFieldsReqDto();
        if (reqDto != null) {
            receptionServiceReq.setLifecyCycleOperationType(reqDto.getLifecyCycleOperationType());//SimpleFieldAssign//sourceId:431659_1_21550
        }

        /*M2-接收字段生命周期操作类型[4007]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getLifecyCycleOperationType(), "D2判断生命周期操作(公共)-M2-接收字段生命周期操作类型-生命周期操作类型不能为空", false);
        receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);


        if ((reqDto != null && reqDto.getLifecyCycleOperationType() != null && reqDto.getLifecyCycleOperationType().equals("DELETE"))) {
            //if(D2判断生命周期操作(公共).生命周期操作类型 等于 删除)  21551

//ModelCode: receptionService
            ObtainReceiveFieldsRespDto receptionServiceRes_1 = null;
            ObtainReceiveFieldsReqDto receptionServiceReq_1 = new ObtainReceiveFieldsReqDto();
            receptionServiceReq_1.setSubjectLifeCycle("EDITING");//sourceId:431660_1_37685

            /*M2-约定删除的主体生命周期为正在编辑[4007]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getSubjectLifeCycle(), "D2判断生命周期操作(公共)-M2-约定删除的主体生命周期为正在编辑-主体生命周期不能为空", false);
            receptionServiceRes_1 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_1);


            receptionServiceRes_2 = receptionServiceRes_1;
        } else if ((reqDto != null && reqDto.getLifecyCycleOperationType() != null && reqDto.getLifecyCycleOperationType().equals("ARCHIVE"))) {
            //elseif(D2判断生命周期操作(公共).生命周期操作类型 等于 存档)  21553

//ModelCode: receptionService
            ObtainReceiveFieldsRespDto receptionServiceRes_3 = null;
            ObtainReceiveFieldsReqDto receptionServiceReq_2 = new ObtainReceiveFieldsReqDto();
            receptionServiceReq_2.setArchivngType("NOT_ARCHIVE");//sourceId:431662_1_21556
            receptionServiceReq_2.setIsArchive("FALSE");//sourceId:431663_1_21556

            /*M2-约定想存档状态[4007]  用于特殊方法接收上游入参。 */

            receptionServiceRes_3 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_2);


            receptionServiceRes_4 = receptionServiceRes_3;
        } else if ((reqDto != null && reqDto.getLifecyCycleOperationType() != null && reqDto.getLifecyCycleOperationType().equals("UNDO_ARCHIVE"))) {
            //elseif(D2判断生命周期操作(公共).生命周期操作类型 等于 撤销存档)  21554

//ModelCode: receptionService
            ObtainReceiveFieldsRespDto receptionServiceRes_5 = null;
            ObtainReceiveFieldsReqDto receptionServiceReq_3 = new ObtainReceiveFieldsReqDto();
            receptionServiceReq_3.setArchivngType("TOBE_ARCHIVING");//sourceId:431666_1_21557
            receptionServiceReq_3.setIsArchive("FALSE");//sourceId:431667_1_21557

            /*M2-约定撤销存档状态[4007]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getArchivngType(), "D2判断生命周期操作(公共)-M2-约定撤销存档状态-存档类型不能为空", false);
            Assert.isNull(receptionServiceReq_3.getIsArchive(), "D2判断生命周期操作(公共)-M2-约定撤销存档状态-是否存档不能为空", false);
            receptionServiceRes_5 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_3);


            receptionServiceRes_6 = receptionServiceRes_5;
        }
        JudgeLifecycleActionsComRespDto retData = new JudgeLifecycleActionsComRespDto();
        if (receptionServiceRes_4 != null) {
            retData.setArchivngType(receptionServiceRes_4.getArchivngType());//SimpleFieldAssign//sourceId:431671_1
            retData.setIsArchive(receptionServiceRes_4.getIsArchive());//SimpleFieldAssign//sourceId:431672_1
        }
        if (receptionServiceRes_6 != null) {
            retData.setArchivngType(receptionServiceRes_6.getArchivngType());//SimpleFieldAssign//sourceId:431671_1
            retData.setIsArchive(receptionServiceRes_6.getIsArchive());//SimpleFieldAssign//sourceId:431672_1
        }
        if (receptionServiceRes_2 != null) {
            retData.setSubjectLifeCycle(receptionServiceRes_2.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:431673_1
        }


        return retData;
    }

    /**
     * D2执行取排序列表中上一条数据服务(公共)[5236]
     * gen by moon at 11/20/2022, 11:12:35 PM
     */
    @Trace(operationName = "D2执行取排序列表中上一条数据服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementGetLastFromDataListComRespDto implementGetLastFromDataListCom(ImplementGetLastFromDataListComReqDto reqDto) {


        QueryGetLastFromDataListDetailComRespDto getLastFromDataListRes_1 = null;
//步骤0: M2取排序列表中上一条数据(特殊方法) - queryGetLastFromDataListDetailCom
        //ModelCode: getLastFromDataList
        QueryGetLastFromDataListDetailComRespDto getLastFromDataListRes = null;
        QueryGetLastFromDataListDetailComReqDto getLastFromDataListReq = new QueryGetLastFromDataListDetailComReqDto();
        if (reqDto != null && reqDto.getGetLastFromDataSpecifiedList() != null && !CollectionUtil.isEmpty(reqDto.getGetLastFromDataSpecifiedList())) {
            getLastFromDataListReq.setGetLastFromDataSpecifiedList(reqDto.getGetLastFromDataSpecifiedList().stream().map(item -> BeanUtil.toBean(item, GetLastFromDataSpecifiedDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:443416_1
        }
        if (reqDto != null) {
            getLastFromDataListReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:445057_1
            getLastFromDataListReq.setOrderSizeType(reqDto.getOrderSizeType());//SimpleFieldAssign//sourceId:443417_1
        }

        /*M2取排序列表中上一条数据(特殊方法)[5235]  入参数据集，字段（主键ID）。数据集按排序字段已经排序，根据入参字段，找到数据集中的上一条记录 */

        getLastFromDataListRes = nbInterfaceMode.queryGetLastFromDataListDetailCom(getLastFromDataListReq);


        getLastFromDataListRes_1 = getLastFromDataListRes;

        ImplementGetLastFromDataListComRespDto retData = new ImplementGetLastFromDataListComRespDto();
        if (getLastFromDataListRes_1 != null) {
            retData.setCommPrimaryKey(getLastFromDataListRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:443421_1
        }


        return retData;
    }

    /**
     * D2执行多数据集取并集(公共)[5320]
     * gen by moon at 4/2/2023, 2:53:48 PM
     */
    @Trace(operationName = "D2执行多数据集取并集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsCom(ImplementUnionMultipleDataSetsComReqDto reqDto) {


        ImplementUnionMultipleDataSetsRespDto collectionsMergeDataRes_1 = null;
//步骤0: M2执行多数据集取并集（特殊方法） - implementUnionMultipleDataSets
        //ModelCode: collectionsMergeData
        ImplementUnionMultipleDataSetsRespDto collectionsMergeDataRes = null;
        ImplementUnionMultipleDataSetsReqDto collectionsMergeDataReq = new ImplementUnionMultipleDataSetsReqDto();
        if (reqDto != null && reqDto.getDataSetsListOne() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())) {
            collectionsMergeDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:462931_1
        }
        if (reqDto != null && reqDto.getDataSetsListTwo() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())) {
            collectionsMergeDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:462932_1
        }

        /*M2执行多数据集取并集（特殊方法）[5319]  入参多个数据集，取并集 */

        collectionsMergeDataRes = nbInterfaceMode.implementUnionMultipleDataSets(collectionsMergeDataReq);


        collectionsMergeDataRes_1 = collectionsMergeDataRes;

        ImplementUnionMultipleDataSetsComRespDto retData = new ImplementUnionMultipleDataSetsComRespDto();
        if (collectionsMergeDataRes_1 != null) {
            retData.setUnionMultipleDataSetsList(collectionsMergeDataRes_1.getUnionMultipleDataSetsList().stream().map(item -> BeanUtil.toBean(item, UnionMultipleDataSetsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:462936_1
        }


        return retData;
    }

    /**
     * D2-获取内存中业务字段(公共)[5343]
     * gen by moon at 12/3/2022, 4:35:09 PM
     */
    @Trace(operationName = "D2-获取内存中业务字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainGetPublicFieldCacheComRespDto obtainGetPublicFieldCacheCom(ObtainGetPublicFieldCacheComReqDto reqDto) {


        ObtainGetPublicFieldCacheRespDto getPublicFieldCacheRes_1 = null;
//步骤0: M2-获取内存中业务字段（特殊方法） - obtainGetPublicFieldCache
        //ModelCode: getPublicFieldCache
        ObtainGetPublicFieldCacheRespDto getPublicFieldCacheRes = null;
        ObtainGetPublicFieldCacheReqDto getPublicFieldCacheReq = new ObtainGetPublicFieldCacheReqDto();


        /*M2-获取内存中业务字段（特殊方法）[5342]  用于定时任务/接口执行时，获取执行所需的缓存中业务字段信息，供定时任务/接口中虚拟用况使用 */

        getPublicFieldCacheRes = nbInterfaceMode.obtainGetPublicFieldCache(getPublicFieldCacheReq);


        getPublicFieldCacheRes_1 = getPublicFieldCacheRes;

        ObtainGetPublicFieldCacheComRespDto retData = new ObtainGetPublicFieldCacheComRespDto();
        if (getPublicFieldCacheRes_1 != null) {
            retData.setTargetCycleContentTypeCode(getPublicFieldCacheRes_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:465549_1
            retData.setTargetCycleContentId(getPublicFieldCacheRes_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:465550_1
            retData.setReportType(getPublicFieldCacheRes_1.getReportType());//SimpleFieldAssign//sourceId:465554_1
            retData.setReportManagementModel(getPublicFieldCacheRes_1.getReportManagementModel());//SimpleFieldAssign//sourceId:465555_1
            retData.setIsOpenCustomReport(getPublicFieldCacheRes_1.getIsOpenCustomReport());//SimpleFieldAssign//sourceId:465641_1
            retData.setCycleId(getPublicFieldCacheRes_1.getCycleId());//SimpleFieldAssign//sourceId:465551_1
            retData.setCycleTypeCode(getPublicFieldCacheRes_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:465645_1
            retData.setCycleStartTime(getPublicFieldCacheRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:465552_1
            retData.setCycleEndTime(getPublicFieldCacheRes_1.getCycleEndTime());//SimpleFieldAssign//sourceId:465553_1
            retData.setLastCycleType(getPublicFieldCacheRes_1.getLastCycleType());//SimpleFieldAssign//sourceId:465611_1
            retData.setFatherCycleType(getPublicFieldCacheRes_1.getFatherCycleType());//SimpleFieldAssign//sourceId:465612_1
            retData.setMidCycleType(getPublicFieldCacheRes_1.getMidCycleType());//SimpleFieldAssign//sourceId:465613_1
            retData.setSubcycleType(getPublicFieldCacheRes_1.getSubcycleType());//SimpleFieldAssign//sourceId:465614_1
            retData.setIrregularCycleType(getPublicFieldCacheRes_1.getIrregularCycleType());//SimpleFieldAssign//sourceId:465615_1
            retData.setTargetId(getPublicFieldCacheRes_1.getTargetId());//SimpleFieldAssign//sourceId:465556_1
            retData.setEvaluationTemplateId(getPublicFieldCacheRes_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:465557_1
            retData.setSpaceId(getPublicFieldCacheRes_1.getSpaceId());//SimpleFieldAssign//sourceId:465558_1
            retData.setSubjectiveScorePoint(getPublicFieldCacheRes_1.getSubjectiveScorePoint());//SimpleFieldAssign//sourceId:468823_1
            retData.setDecimalDigitsLastRules(getPublicFieldCacheRes_1.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:468824_1
            retData.setCurSubjectiveScoreWeight(getPublicFieldCacheRes_1.getCurSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:468825_1
            retData.setProcessSubjectiveScoreWeight(getPublicFieldCacheRes_1.getProcessSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:468826_1
            retData.setSubjectiveScoreCountRule(getPublicFieldCacheRes_1.getSubjectiveScoreCountRule());//SimpleFieldAssign//sourceId:469012_1
            retData.setDecimalPointRules(getPublicFieldCacheRes_1.getDecimalPointRules());//SimpleFieldAssign//sourceId:469869_1
            retData.setWeightDecimalPoint(getPublicFieldCacheRes_1.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:470647_1
            retData.setDegreeDecimalPoint(getPublicFieldCacheRes_1.getDegreeDecimalPoint());//SimpleFieldAssign//sourceId:470648_1
            retData.setProgressDecimalPoint(getPublicFieldCacheRes_1.getProgressDecimalPoint());//SimpleFieldAssign//sourceId:470649_1
            retData.setTargetValueType(getPublicFieldCacheRes_1.getTargetValueType());//SimpleFieldAssign//sourceId:470717_1
            retData.setTargetDivisionSame(getPublicFieldCacheRes_1.getTargetDivisionSame());//SimpleFieldAssign//sourceId:470718_1
            retData.setLevelNumber(getPublicFieldCacheRes_1.getLevelNumber());//SimpleFieldAssign//sourceId:470719_1
            retData.setQuantityObjectiveNoValue(getPublicFieldCacheRes_1.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:471187_1
            retData.setIsSubjectiveScoring(getPublicFieldCacheRes_1.getIsSubjectiveScoring());//SimpleFieldAssign//sourceId:471481_1
            retData.setSubjectiveRatingTotalValueUnit(getPublicFieldCacheRes_1.getSubjectiveRatingTotalValueUnit());//SimpleFieldAssign//sourceId:472364_1
            retData.setSubjectiveRatingTotalValue(getPublicFieldCacheRes_1.getSubjectiveRatingTotalValue());//SimpleFieldAssign//sourceId:472365_1
            retData.setReportObjectSetCode(getPublicFieldCacheRes_1.getReportObjectSetCode());//SimpleFieldAssign//sourceId:472366_1
            retData.setReportObjectSetCode(getPublicFieldCacheRes_1.getReportObjectSetCode());//SimpleFieldAssign//sourceId:472367_1
            retData.setIsParentCycle(getPublicFieldCacheRes_1.getIsParentCycle());//SimpleFieldAssign//sourceId:473044_1
            retData.setIsSubCycle(getPublicFieldCacheRes_1.getIsSubCycle());//SimpleFieldAssign//sourceId:473045_1
            retData.setIsMetaphase(getPublicFieldCacheRes_1.getIsMetaphase());//SimpleFieldAssign//sourceId:473046_1
            retData.setIsProcessCycleStage(getPublicFieldCacheRes_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:473047_1
            retData.setIsDefinedExecuteCycleStage(getPublicFieldCacheRes_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:473048_1
            retData.setSchemeDataPara(getPublicFieldCacheRes_1.getSchemeDataPara());//SimpleFieldAssign//sourceId:482868_1
        }


        return retData;
    }

    /**
     * D2执行两数据集去除已存在(公共)[5347]
     * gen by moon at 2/8/2023, 2:21:11 PM
     */
    @Trace(operationName = "D2执行两数据集去除已存在(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTwoDataRemovalExistsComRespDto implementTwoDataRemovalExistsCom(ImplementTwoDataRemovalExistsComReqDto reqDto) {


        ImplementTwoDataRemovalExistsComRespDto collectionRemoveExistingDataRes_1 = null;
//步骤0: M2执行两数据集去除已存在（特殊方法） - implementTwoDataRemovalExists
        //ModelCode: collectionRemoveExistingData
        ImplementTwoDataRemovalExistsComRespDto collectionRemoveExistingDataRes = null;
        ImplementTwoDataRemovalExistsComReqDto collectionRemoveExistingDataReq = new ImplementTwoDataRemovalExistsComReqDto();
        if (reqDto != null && reqDto.getDataSetsListOne() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())) {
            collectionRemoveExistingDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465569_1
        }
        if (reqDto != null && reqDto.getDataSetsListTwo() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())) {
            collectionRemoveExistingDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465570_1
        }

        /*M2执行两数据集去除已存在（特殊方法）[5345]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */

        collectionRemoveExistingDataRes = nbInterfaceMode.implementTwoDataRemovalExistsCom(collectionRemoveExistingDataReq);


        collectionRemoveExistingDataRes_1 = collectionRemoveExistingDataRes;

        ImplementTwoDataRemovalExistsComRespDto retData = new ImplementTwoDataRemovalExistsComRespDto();
        if (collectionRemoveExistingDataRes_1 != null) {
            retData.setTwoDataRemovalExistsList(collectionRemoveExistingDataRes_1.getTwoDataRemovalExistsList().stream().map(item -> BeanUtil.toBean(item, TwoDataRemovalExistsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465622_1
        }


        return retData;
    }

    /**
     * D2执行入参时间点获取两个月时间点(公共)[5340]
     * gen by moon at 5/27/2023, 10:12:14 PM
     */
    @Trace(operationName = "D2执行入参时间点获取两个月时间点(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementInputTimePointGetTwoTimePointsComRespDto implementInputTimePointGetTwoTimePointsCom(ImplementInputTimePointGetTwoTimePointsComReqDto reqDto) {


        ObtainReceiveFieldsRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getCustomField1() != null && reqDto.getCustomField1().equals("POSTPONE_REPORT"))) {
            //if(D2执行入参时间点获取两个月时间点(公共).节假日处理策略配置答案值 等于 推迟汇报)  43268

            //ModelCode: findStartTimeOfCurMonAndEndTimeOfNextMon
            ImplementGetTwoTimePointsRespDto findStartTimeOfCurMonAndEndTimeOfNextMonRes = null;
            ImplementGetTwoTimePointsReqDto findStartTimeOfCurMonAndEndTimeOfNextMonReq = new ImplementGetTwoTimePointsReqDto();
            if (reqDto != null) {
                findStartTimeOfCurMonAndEndTimeOfNextMonReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:465579_1_43269
            }

            /*M2-执行入参时间点获取当前及下一个月时间点（特殊方法）[5338]  入参时间字段A，根据A字段的时间，查找所在当前月，以及下个月。返回当前月的开始时间+下个月的结束时间 */
            Assert.isNull(findStartTimeOfCurMonAndEndTimeOfNextMonReq.getComTimeField(), "D2执行入参时间点获取两个月时间点(公共)-M2-执行入参时间点获取当前及下一个月时间点（特殊方法）-通用时间字段不能为空", false);
            findStartTimeOfCurMonAndEndTimeOfNextMonRes = nbInterfaceMode.implementGetTwoTimePoints(findStartTimeOfCurMonAndEndTimeOfNextMonReq);


//ModelCode: receptionService
            ObtainReceiveFieldsRespDto receptionServiceRes = null;
            ObtainReceiveFieldsReqDto receptionServiceReq = new ObtainReceiveFieldsReqDto();
            if (findStartTimeOfCurMonAndEndTimeOfNextMonRes != null) {
                receptionServiceReq.setCycleStartTime(findStartTimeOfCurMonAndEndTimeOfNextMonRes.getCycleStartTime());//SimpleFieldAssign//sourceId:987834_1_43272
                receptionServiceReq.setCycleEndTime(findStartTimeOfCurMonAndEndTimeOfNextMonRes.getCycleEndTime());//SimpleFieldAssign//sourceId:987835_1_43272
            }

            /*约定字段：周期开始时间、周期结束时间[4007]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getCycleStartTime(), "D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期开始时间不能为空", false);
            Assert.isNull(receptionServiceReq.getCycleEndTime(), "D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期结束时间不能为空", false);
            receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        } else if ((reqDto != null && reqDto.getCustomField1() != null && reqDto.getCustomField1().equals("ADVANCE_REPORT"))) {
            //elseif(D2执行入参时间点获取两个月时间点(公共).节假日处理策略配置答案值 等于 提前汇报)  43270

//ModelCode: findStartTimeOfCurMonAndEndTimeOfForwardMon
            ImplementInputTimePointGetForwordTwoTimePointsRespDto findStartTimeOfCurMonAndEndTimeOfForwardMonRes = null;
            ImplementInputTimePointGetForwordTwoTimePointsReqDto findStartTimeOfCurMonAndEndTimeOfForwardMonReq = new ImplementInputTimePointGetForwordTwoTimePointsReqDto();
            if (reqDto != null) {
                findStartTimeOfCurMonAndEndTimeOfForwardMonReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:987840_1_43271
            }

            /*M2-执行入参时间点获取当前及前一个月时间点（特殊方法）[6974]  入参时间字段A，根据A字段的时间，查找所在当前月，以及上个个月。返回上个月的开始时间+当前月的结束时间 */
            Assert.isNull(findStartTimeOfCurMonAndEndTimeOfForwardMonReq.getComTimeField(), "D2执行入参时间点获取两个月时间点(公共)-M2-执行入参时间点获取当前及前一个月时间点（特殊方法）-通用时间字段不能为空", false);
            findStartTimeOfCurMonAndEndTimeOfForwardMonRes = nbInterfaceMode.implementInputTimePointGetForwordTwoTimePoints(findStartTimeOfCurMonAndEndTimeOfForwardMonReq);


//ModelCode: receptionService
            ObtainReceiveFieldsRespDto receptionServiceRes_2 = null;
            ObtainReceiveFieldsReqDto receptionServiceReq_1 = new ObtainReceiveFieldsReqDto();
            if (findStartTimeOfCurMonAndEndTimeOfForwardMonRes != null) {
                receptionServiceReq_1.setCycleStartTime(findStartTimeOfCurMonAndEndTimeOfForwardMonRes.getCycleStartTime());//SimpleFieldAssign//sourceId:987834_1_43273
                receptionServiceReq_1.setCycleEndTime(findStartTimeOfCurMonAndEndTimeOfForwardMonRes.getCycleEndTime());//SimpleFieldAssign//sourceId:987835_1_43273
            }

            /*约定字段：周期开始时间、周期结束时间[4007]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getCycleStartTime(), "D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期开始时间不能为空", false);
            Assert.isNull(receptionServiceReq_1.getCycleEndTime(), "D2执行入参时间点获取两个月时间点(公共)-约定字段：周期开始时间、周期结束时间-周期结束时间不能为空", false);
            receptionServiceRes_2 = nbInterfaceMode.obtainReceiveFields(receptionServiceReq_1);


            receptionServiceRes_1 = receptionServiceRes_2;
        }
        ImplementInputTimePointGetTwoTimePointsComRespDto retData = new ImplementInputTimePointGetTwoTimePointsComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setCycleStartTime(receptionServiceRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:987847_1
            retData.setCycleEndTime(receptionServiceRes_1.getCycleEndTime());//SimpleFieldAssign//sourceId:987848_1
        }


        return retData;
    }

    /**
     * D2执行入参时间匹配记录(公共)[5351]
     * gen by moon at 12/2/2022, 10:21:29 PM
     */
    @Trace(operationName = "D2执行入参时间匹配记录(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMatchRecordInputTimePointComRespDto implementMatchRecordInputTimePointCom(ImplementMatchRecordInputTimePointComReqDto reqDto) {


        MatchRecordInputTimePointComRespDto matchRecordBySpecRecRes_1 = null;
//步骤0: M2执行入参时间匹配记录（特殊方法） - implementMatchRecordInputTimePoint
        //ModelCode: matchRecordBySpecRec
        MatchRecordInputTimePointComRespDto matchRecordBySpecRecRes = null;
        MatchRecordInputTimePointComReqDto matchRecordBySpecRecReq = new MatchRecordInputTimePointComReqDto();
        if (reqDto != null) {
            matchRecordBySpecRecReq.setMatchRecordInputTimePointList(reqDto.getMatchRecordInputTimePointList().stream().map(item -> BeanUtil.toBean(item, MatchRecordInputTimePointDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:465975_1
            matchRecordBySpecRecReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:465976_1
        }

        /*M2执行入参时间匹配记录（特殊方法）[5350]  入参数据集+单字段。通过入参单字段到数据集中查询指定同名字段值相同的所有记录 */
        Assert.isNull(matchRecordBySpecRecReq.getComTimeField(), "D2执行入参时间匹配记录(公共)-M2执行入参时间匹配记录（特殊方法）-通用时间字段不能为空", false);
        matchRecordBySpecRecRes = nbInterfaceMode.matchRecordInputTimePointCom(matchRecordBySpecRecReq);


        matchRecordBySpecRecRes_1 = matchRecordBySpecRecRes;

        ImplementMatchRecordInputTimePointComRespDto retData = new ImplementMatchRecordInputTimePointComRespDto();
        if (matchRecordBySpecRecRes_1 != null) {
            retData.setCustomField(matchRecordBySpecRecRes_1.getCustomField());//SimpleFieldAssign//sourceId:466027_1
            retData.setComTimeField(matchRecordBySpecRecRes_1.getComTimeField());//SimpleFieldAssign//sourceId:466028_1
        }


        return retData;
    }

    /**
     * D2执行两点时间段天数(公共)[5353]
     * gen by moon at 12/2/2022, 10:21:35 PM
     */
    @Trace(operationName = "D2执行两点时间段天数(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTwoPointTimePeriodDaysComRespDto implementTwoPointTimePeriodDaysCom(ImplementTwoPointTimePeriodDaysComReqDto reqDto) {


        TwoPointTimePeriodDaysComRespDto twoPointTimePeriodDaysRes_1 = null;
//步骤0: M2执行两点时间段天数（特殊方法） - implementTwoPointTimePeriodDays
        //ModelCode: twoPointTimePeriodDays
        TwoPointTimePeriodDaysComRespDto twoPointTimePeriodDaysRes = null;
        TwoPointTimePeriodDaysComReqDto twoPointTimePeriodDaysReq = new TwoPointTimePeriodDaysComReqDto();
        if (reqDto != null) {
            twoPointTimePeriodDaysReq.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:465998_1
            twoPointTimePeriodDaysReq.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:465999_1
            twoPointTimePeriodDaysReq.setTwoPointTimePeriodType(reqDto.getTwoPointTimePeriodType());//SimpleFieldAssign//sourceId:466008_1
        }

        /*M2执行两点时间段天数（特殊方法）[5352]   */
        Assert.isNull(twoPointTimePeriodDaysReq.getComTimeField1(), "D2执行两点时间段天数(公共)-M2执行两点时间段天数（特殊方法）-通用时间字段1不能为空", false);
        Assert.isNull(twoPointTimePeriodDaysReq.getComTimeField2(), "D2执行两点时间段天数(公共)-M2执行两点时间段天数（特殊方法）-通用时间字段2不能为空", false);
        Assert.isNull(twoPointTimePeriodDaysReq.getTwoPointTimePeriodType(), "D2执行两点时间段天数(公共)-M2执行两点时间段天数（特殊方法）-两点时间段含头尾类型不能为空", false);
        twoPointTimePeriodDaysRes = nbInterfaceMode.twoPointTimePeriodDaysCom(twoPointTimePeriodDaysReq);


        twoPointTimePeriodDaysRes_1 = twoPointTimePeriodDaysRes;

        ImplementTwoPointTimePeriodDaysComRespDto retData = new ImplementTwoPointTimePeriodDaysComRespDto();
        if (twoPointTimePeriodDaysRes_1 != null) {
            retData.setCalcCount(twoPointTimePeriodDaysRes_1.getCalcCount());//SimpleFieldAssign//sourceId:466003_1
        }


        return retData;
    }

    /**
     * D2执行时间点区间内前后偏移N天(公共)[5356]
     * gen by moon at 3/3/2023, 11:28:58 PM
     */
    @Trace(operationName = "D2执行时间点区间内前后偏移N天(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementOffsetNdaysInTimePointIntervalComRespDto implementOffsetNdaysInTimePointIntervalCom(ImplementOffsetNdaysInTimePointIntervalComReqDto reqDto) {


        OffsetNdaysInTimePointIntervalComRespDto offsetNDaysInTimePointIntervalRes_1 = null;
//步骤0: M2执行时间点区间内前后偏移N天（特殊方法） - implementOffsetNdaysInTimePointInterval
        //ModelCode: offsetNDaysInTimePointInterval
        OffsetNdaysInTimePointIntervalComRespDto offsetNDaysInTimePointIntervalRes = null;
        OffsetNdaysInTimePointIntervalComReqDto offsetNDaysInTimePointIntervalReq = new OffsetNdaysInTimePointIntervalComReqDto();
        if (reqDto != null) {
            offsetNDaysInTimePointIntervalReq.setNumCompareResult(reqDto.getNumCompareResult());//SimpleFieldAssign//sourceId:466503_1
            offsetNDaysInTimePointIntervalReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:466505_1
            offsetNDaysInTimePointIntervalReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:468303_1
        }
        if (reqDto != null && reqDto.getOffsetNdaysInTimePointIntervalList() != null && !CollectionUtil.isEmpty(reqDto.getOffsetNdaysInTimePointIntervalList())) {
            offsetNDaysInTimePointIntervalReq.setOffsetNdaysInTimePointIntervalList(reqDto.getOffsetNdaysInTimePointIntervalList().stream().map(item -> BeanUtil.toBean(item, OffsetNdaysInTimePointIntervalDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:466504_1
        }

        /*M2执行时间点区间内前后偏移N天（特殊方法）[5355]   */
        Assert.isNull(offsetNDaysInTimePointIntervalReq.getNumCompareResult(), "D2执行时间点区间内前后偏移N天(公共)-M2执行时间点区间内前后偏移N天（特殊方法）-数值比较结果不能为空", false);
        Assert.isNull(offsetNDaysInTimePointIntervalReq.getComTimeField(), "D2执行时间点区间内前后偏移N天(公共)-M2执行时间点区间内前后偏移N天（特殊方法）-通用时间字段不能为空", false);
        Assert.isNull(offsetNDaysInTimePointIntervalReq.getComNumField(), "D2执行时间点区间内前后偏移N天(公共)-M2执行时间点区间内前后偏移N天（特殊方法）-通用数值字段（整数型）不能为空", false);
        offsetNDaysInTimePointIntervalRes = nbInterfaceMode.offsetNdaysInTimePointIntervalCom(offsetNDaysInTimePointIntervalReq);


        offsetNDaysInTimePointIntervalRes_1 = offsetNDaysInTimePointIntervalRes;

        ImplementOffsetNdaysInTimePointIntervalComRespDto retData = new ImplementOffsetNdaysInTimePointIntervalComRespDto();
        if (offsetNDaysInTimePointIntervalRes_1 != null) {
            retData.setCustomField(offsetNDaysInTimePointIntervalRes_1.getCustomField());//SimpleFieldAssign//sourceId:466512_1
            retData.setComTimeField(offsetNDaysInTimePointIntervalRes_1.getComTimeField());//SimpleFieldAssign//sourceId:466513_1
        }


        return retData;
    }

    /**
     * D2执行分析自然日数据集(公共)[5377]
     * gen by moon at 12/4/2022, 6:46:28 PM
     */
    @Trace(operationName = "D2执行分析自然日数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyzeNaturalDayDataComRespDto implementAnalyzeNaturalDayDataCom(ImplementAnalyzeNaturalDayDataComReqDto reqDto) {


        AnalyzeNaturalDayDataComRespDto analyzeNaturalDayDataRes_1 = null;
//步骤0: M2执行分析自然日数据集（特殊方法） - implementAnalyzeNaturalDayData
        //ModelCode: analyzeNaturalDayData
        AnalyzeNaturalDayDataComRespDto analyzeNaturalDayDataRes = null;
        AnalyzeNaturalDayDataComReqDto analyzeNaturalDayDataReq = new AnalyzeNaturalDayDataComReqDto();
        if (reqDto != null) {
            analyzeNaturalDayDataReq.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:482536_1
            analyzeNaturalDayDataReq.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:482537_1
            analyzeNaturalDayDataReq.setTwoPointTimePeriodType(reqDto.getTwoPointTimePeriodType());//SimpleFieldAssign//sourceId:486868_1
        }

        /*M2执行分析自然日数据集（特殊方法）[5376]  入参开始时间，结束时间，输出数据集。计算开始和结束时间内的所有自然日（包含开始和结束两天） */
        Assert.isNull(analyzeNaturalDayDataReq.getComTimeField1(), "D2执行分析自然日数据集(公共)-M2执行分析自然日数据集（特殊方法）-通用时间字段1不能为空", false);
        Assert.isNull(analyzeNaturalDayDataReq.getComTimeField2(), "D2执行分析自然日数据集(公共)-M2执行分析自然日数据集（特殊方法）-通用时间字段2不能为空", false);
        Assert.isNull(analyzeNaturalDayDataReq.getTwoPointTimePeriodType(), "D2执行分析自然日数据集(公共)-M2执行分析自然日数据集（特殊方法）-两点时间段含头尾类型不能为空", false);
        analyzeNaturalDayDataRes = nbInterfaceMode.analyzeNaturalDayDataCom(analyzeNaturalDayDataReq);


        analyzeNaturalDayDataRes_1 = analyzeNaturalDayDataRes;

        ImplementAnalyzeNaturalDayDataComRespDto retData = new ImplementAnalyzeNaturalDayDataComRespDto();
        if (analyzeNaturalDayDataRes_1 != null) {
            retData.setAnalyzeNaturalDayDataList(analyzeNaturalDayDataRes_1.getAnalyzeNaturalDayDataList().stream().map(item -> BeanUtil.toBean(item, AnalyzeNaturalDayDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:482541_1
        }


        return retData;
    }

    /**
     * D2-执行计算时间范围服务(公共)[5409]
     * gen by moon at 5/7/2023, 12:57:07 PM
     */
    @Trace(operationName = "D2-执行计算时间范围服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCountTimeScopeServiceComRespDto implementCountTimeScopeServiceCom(ImplementCountTimeScopeServiceComReqDto reqDto) {


        ImplementCountTimeScopeServiceComRespDto getTimeRangeRes_1 = null;
//步骤0: M2执行计算时间范围服务(公共) - implementCountTimeScopeServiceCom
        //ModelCode: getTimeRange
        ImplementCountTimeScopeServiceComRespDto getTimeRangeRes = null;
        ImplementCountTimeScopeServiceComReqDto getTimeRangeReq = new ImplementCountTimeScopeServiceComReqDto();
        if (reqDto != null) {
            getTimeRangeReq.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:489915_1
            getTimeRangeReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:489914_1
            getTimeRangeReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:489913_1
        }

        /*M2执行计算时间范围服务(公共)[5408]  入参：数量，当前时间，数量单位（默认年）。逻辑：当前时间+数量（年）出参：开始时间（当前时间），结束时间（计算后的时间） */
        Assert.isNull(getTimeRangeReq.getComTimeField1(), "D2-执行计算时间范围服务(公共)-M2执行计算时间范围服务(公共)-通用时间字段1不能为空", false);
        Assert.isNull(getTimeRangeReq.getComNumField(), "D2-执行计算时间范围服务(公共)-M2执行计算时间范围服务(公共)-通用数值字段（整数型）不能为空", false);
        Assert.isNull(getTimeRangeReq.getCycleTypeCode(), "D2-执行计算时间范围服务(公共)-M2执行计算时间范围服务(公共)-周期类型标识不能为空", false);
        getTimeRangeRes = nbInterfaceMode.implementCountTimeScopeServiceCom(getTimeRangeReq);


        getTimeRangeRes_1 = getTimeRangeRes;

        ImplementCountTimeScopeServiceComRespDto retData = new ImplementCountTimeScopeServiceComRespDto();
        if (getTimeRangeRes_1 != null) {
            retData.setStartTime(getTimeRangeRes_1.getStartTime());//SimpleFieldAssign//sourceId:489920_1
            retData.setEndTime(getTimeRangeRes_1.getEndTime());//SimpleFieldAssign//sourceId:489921_1
        }


        return retData;
    }

    /**
     * D2执行数据集减一条记录(公共)[5415]
     * gen by moon at 12/7/2022, 10:24:16 PM
     */
    @Trace(operationName = "D2执行数据集减一条记录(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSubtractOneComRespDto implementDataSubtractOneCom(ImplementDataSubtractOneComReqDto reqDto) {


        ImplementDataSubtractOneRespDto dataFilterSpecRecByRes_1 = null;
//步骤0: M2执行数据集减一条记录（特殊方法） - implementDataSubtractOne
        //ModelCode: dataFilterSpecRecBy
        ImplementDataSubtractOneRespDto dataFilterSpecRecByRes = null;
        ImplementDataSubtractOneReqDto dataFilterSpecRecByReq = new ImplementDataSubtractOneReqDto();
        if (reqDto != null) {
            dataFilterSpecRecByReq.setDataSubtractOneList(reqDto.getDataSubtractOneList());//list-field-assign//sourceId:490876_1
            dataFilterSpecRecByReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:490877_1
        }

    /*M2执行数据集减一条记录（特殊方法）[5414]  目前用于购物车步骤判断。入参：步骤数据集+三个步骤字段（字段名与数据集中步骤编码相同）
处理逻辑：入参步骤字段值不为1，则将数据集中步骤编码同名的记录从出参数据集中删除 */
        Assert.isNull(dataFilterSpecRecByReq.getCustomField(), "D2执行数据集减一条记录(公共)-M2执行数据集减一条记录（特殊方法）-自定义字段不能为空", false);
        dataFilterSpecRecByRes = nbInterfaceMode.implementDataSubtractOne(dataFilterSpecRecByReq);


        dataFilterSpecRecByRes_1 = dataFilterSpecRecByRes;

        ImplementDataSubtractOneComRespDto retData = new ImplementDataSubtractOneComRespDto();
        if (dataFilterSpecRecByRes_1 != null) {
            retData.setDataSubtractOneList(dataFilterSpecRecByRes_1.getDataSubtractOneList());//list-field-assign//sourceId:490886_1
        }


        return retData;
    }

    /**
     * D2执行数据集按入参过滤指定记录服务(公共)[5477]
     * gen by moon at 3/18/2023, 3:21:06 PM
     */
    @Trace(operationName = "D2执行数据集按入参过滤指定记录服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataFilterSpecRecByComRespDto implementDataFilterSpecRecByCom(ImplementDataFilterSpecRecByComReqDto reqDto) {


        ImplementDataFilterSpecRecByComRespDto dataFilterSpecRecByRes_1 = null;
//步骤0: M2执行数据集按入参过滤指定记录(公共) - implementDataFilterSpecRecByCom
        //ModelCode: dataFilterSpecRecBy
        ImplementDataFilterSpecRecByComRespDto dataFilterSpecRecByRes = null;
        ImplementDataFilterSpecRecByComReqDto dataFilterSpecRecByReq = new ImplementDataFilterSpecRecByComReqDto();
        if (reqDto != null && reqDto.getDataFilterSpecRecByList() != null && !CollectionUtil.isEmpty(reqDto.getDataFilterSpecRecByList())) {
            dataFilterSpecRecByReq.setDataFilterSpecRecByList(reqDto.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:520774_1
        }
        if (reqDto != null) {
            dataFilterSpecRecByReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:726385_1
            dataFilterSpecRecByReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:520775_1
            dataFilterSpecRecByReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:766232_1
        }

    /*M2执行数据集按入参过滤指定记录(公共)[5478]  目前用于购物车步骤判断。入参：步骤数据集+三个步骤字段（字段名与数据集中步骤编码相同）
处理逻辑：入参步骤字段值不为1，则将数据集中步骤编码同名的记录从出参数据集中删除 */

        dataFilterSpecRecByRes = nbInterfaceMode.implementDataFilterSpecRecByCom(dataFilterSpecRecByReq);


        dataFilterSpecRecByRes_1 = dataFilterSpecRecByRes;

        ImplementDataFilterSpecRecByComRespDto retData = new ImplementDataFilterSpecRecByComRespDto();
        if (dataFilterSpecRecByRes_1 != null) {
            retData.setDataFilterSpecRecByList(dataFilterSpecRecByRes_1.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:520791_1
        }


        return retData;
    }

    /**
     * D2执行两个数值对比大小(公共)[5551]
     * gen by moon at 12/30/2022, 6:27:45 PM
     */
    @Trace(operationName = "D2执行两个数值对比大小(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeCom(ImplementNumericalContrastMagnitudeComReqDto reqDto) {


        ImplementNumericalContrastMagnitudeRespDto numericalSizeComparisonRes_1 = null;
//步骤0: M2执行两个数值对比大小（特殊方法） - implementNumericalContrastMagnitude
        //ModelCode: numericalSizeComparison
        ImplementNumericalContrastMagnitudeRespDto numericalSizeComparisonRes = null;
        ImplementNumericalContrastMagnitudeReqDto numericalSizeComparisonReq = new ImplementNumericalContrastMagnitudeReqDto();
        if (reqDto != null) {
            numericalSizeComparisonReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:553853_1
            numericalSizeComparisonReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:553852_1
        }

        /*M2执行两个数值对比大小（特殊方法）[4132]  入参A，B两个数值型参数，对比大小。A与B比较，输出大于、等于、小于 */
        Assert.isNull(numericalSizeComparisonReq.getCalcPara1(), "D2执行两个数值对比大小(公共)-M2执行两个数值对比大小（特殊方法）-计算入参1不能为空", false);
        Assert.isNull(numericalSizeComparisonReq.getCalcPara2(), "D2执行两个数值对比大小(公共)-M2执行两个数值对比大小（特殊方法）-计算入参2不能为空", false);
        numericalSizeComparisonRes = nbInterfaceMode.implementNumericalContrastMagnitude(numericalSizeComparisonReq);


        numericalSizeComparisonRes_1 = numericalSizeComparisonRes;

        ImplementNumericalContrastMagnitudeComRespDto retData = new ImplementNumericalContrastMagnitudeComRespDto();
        if (numericalSizeComparisonRes_1 != null) {
            retData.setNumCompareResult(numericalSizeComparisonRes_1.getNumCompareResult());//SimpleFieldAssign//sourceId:553857_1
        }


        return retData;
    }

    /**
     * D2-执行按类型过滤数据集(公共)[5599]
     * gen by moon at 5/27/2024, 7:28:58 PM
     */
    @Trace(operationName = "D2-执行按类型过滤数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataFilterSpecRecByTypeCodeComRespDto implementDataFilterSpecRecByTypeCodeCom(ImplementDataFilterSpecRecByTypeCodeComReqDto reqDto) {


        ImplementDataFilterSpecRecByTypeCodeRespDto dataFilterSpecRecByTypeCodeRes_1 = null;
//步骤0: M2-执行按类型过滤数据集（特殊方法） - implementDataFilterSpecRecByTypeCode
        //ModelCode: dataFilterSpecRecByTypeCode
        ImplementDataFilterSpecRecByTypeCodeRespDto dataFilterSpecRecByTypeCodeRes = null;
        ImplementDataFilterSpecRecByTypeCodeReqDto dataFilterSpecRecByTypeCodeReq = new ImplementDataFilterSpecRecByTypeCodeReqDto();
        if (reqDto != null && reqDto.getDataFilterSpecRecByTypeCodeList() != null && !CollectionUtil.isEmpty(reqDto.getDataFilterSpecRecByTypeCodeList())) {
            dataFilterSpecRecByTypeCodeReq.setDataFilterSpecRecByTypeCodeList(reqDto.getDataFilterSpecRecByTypeCodeList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByTypeCodeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:577780_1
        }
        if (reqDto != null) {
            dataFilterSpecRecByTypeCodeReq.setComCode(reqDto.getComCode());//SimpleFieldAssign//sourceId:577781_1
        }

        /*M2-执行按类型过滤数据集（特殊方法）[5598]  入参数据集（主键+类型等字段）+类型A，按入参的类型A字段过滤数据集，返回类型等于A的数据集 */
        Assert.isNull(dataFilterSpecRecByTypeCodeReq.getComCode(), "D2-执行按类型过滤数据集(公共)-M2-执行按类型过滤数据集（特殊方法）-通用编码标识不能为空", false);
        dataFilterSpecRecByTypeCodeRes = nbInterfaceMode.implementDataFilterSpecRecByTypeCode(dataFilterSpecRecByTypeCodeReq);


        dataFilterSpecRecByTypeCodeRes_1 = dataFilterSpecRecByTypeCodeRes;

        ImplementDataFilterSpecRecByTypeCodeComRespDto retData = new ImplementDataFilterSpecRecByTypeCodeComRespDto();
        if (dataFilterSpecRecByTypeCodeRes_1 != null) {
            retData.setDataFilterSpecRecByTypeCodeList(dataFilterSpecRecByTypeCodeRes_1.getDataFilterSpecRecByTypeCodeList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByTypeCodeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:577785_1
        }


        return retData;
    }

    /**
     * D2执行获取上级非末级的下发状态(公共)[5641]
     * gen by moon at 1/10/2023, 10:46:43 PM
     */
    @Trace(operationName = "D2执行获取上级非末级的下发状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementGainSuperiorNotLastIssueStateComRespDto implementGainSuperiorNotLastIssueStateCom(ImplementGainSuperiorNotLastIssueStateComReqDto reqDto) {


        ImplementGainSuperiorNotLastIssueStateComRespDto gainIssueStateRes_1 = null;
//步骤0: M2执行获取上级非末级的下发状态(公共) - implementGainSuperiorNotLastIssueStateCom
        //ModelCode: gainIssueState
        ImplementGainSuperiorNotLastIssueStateComRespDto gainIssueStateRes = null;
        ImplementGainSuperiorNotLastIssueStateComReqDto gainIssueStateReq = new ImplementGainSuperiorNotLastIssueStateComReqDto();
        if (reqDto != null && reqDto.getSuperiorTargetObjAssistNodeStatusListList() != null && !CollectionUtil.isEmpty(reqDto.getSuperiorTargetObjAssistNodeStatusListList())) {
            gainIssueStateReq.setSuperiorTargetObjAssistNodeStatusListList(reqDto.getSuperiorTargetObjAssistNodeStatusListList().stream().map(item -> BeanUtil.toBean(item, SuperiorTargetObjAssistNodeStatusListDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597368_1
        }
        if (reqDto != null && reqDto.getSubordinateTargetObjAssistNodeStatusList() != null && !CollectionUtil.isEmpty(reqDto.getSubordinateTargetObjAssistNodeStatusList())) {
            gainIssueStateReq.setSubordinateTargetObjAssistNodeStatusList(reqDto.getSubordinateTargetObjAssistNodeStatusList().stream().map(item -> BeanUtil.toBean(item, SubordinateTargetObjAssistNodeStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597363_1
        }

        /*M2执行获取上级非末级的下发状态(公共)[5638]  入参上级目标内容数据集及下级目标内容节点状态，获取上级目标内容下发状态 */

        gainIssueStateRes = nbInterfaceMode.implementGainSuperiorNotLastIssueStateCom(gainIssueStateReq);


        gainIssueStateRes_1 = gainIssueStateRes;

        ImplementGainSuperiorNotLastIssueStateComRespDto retData = new ImplementGainSuperiorNotLastIssueStateComRespDto();
        if (gainIssueStateRes_1 != null) {
            retData.setTargetContGainIssueStateList(gainIssueStateRes_1.getTargetContGainIssueStateList().stream().map(item -> BeanUtil.toBean(item, TargetContGainIssueStateDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597381_1
        }


        return retData;
    }

    /**
     * D2执行多数据集多字段取并集(公共)[5649]
     * gen by moon at 1/11/2023, 5:04:57 AM
     */
    @Trace(operationName = "D2执行多数据集多字段取并集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUnionMultipleManyFieldsDataSetsComRespDto implementUnionMultipleManyFieldsDataSetsCom(ImplementUnionMultipleManyFieldsDataSetsComReqDto reqDto) {


        ImplementUnionMultipleManyFieldsDataSetsRespDto collectionsMergeDataRes_1 = null;
//步骤0: M2执行多数据集多字段取并集（特殊方法） - implementUnionMultipleManyFieldsDataSets
        //ModelCode: collectionsMergeData
        ImplementUnionMultipleManyFieldsDataSetsRespDto collectionsMergeDataRes = null;
        ImplementUnionMultipleManyFieldsDataSetsReqDto collectionsMergeDataReq = new ImplementUnionMultipleManyFieldsDataSetsReqDto();
        if (reqDto != null && reqDto.getDataSetsListOne() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())) {
            collectionsMergeDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:598067_1
        }
        if (reqDto != null && reqDto.getDataSetsListTwo() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())) {
            collectionsMergeDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:598068_1
        }

        /*M2执行多数据集多字段取并集（特殊方法）[5648]  入参多个数据集，取并集 */

        collectionsMergeDataRes = nbInterfaceMode.implementUnionMultipleManyFieldsDataSets(collectionsMergeDataReq);


        collectionsMergeDataRes_1 = collectionsMergeDataRes;

        ImplementUnionMultipleManyFieldsDataSetsComRespDto retData = new ImplementUnionMultipleManyFieldsDataSetsComRespDto();
        if (collectionsMergeDataRes_1 != null) {
            retData.setUnionMultipleDataSetsList(collectionsMergeDataRes_1.getUnionMultipleDataSetsList().stream().map(item -> BeanUtil.toBean(item, UnionMultipleDataSetsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:598090_1
        }


        return retData;
    }

    /**
     * D2执行获取非分工目标内容下发状态(公共)[5643]
     * gen by moon at 1/11/2023, 5:05:06 AM
     */
    @Trace(operationName = "D2执行获取非分工目标内容下发状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementGainNotDivTargetContIssueStateComRespDto implementGainNotDivTargetContIssueStateCom(ImplementGainNotDivTargetContIssueStateComReqDto reqDto) {


        ImplementGainNotDivTargetContIssueStateRespDto singleDatasetObjMergeRes_1 = null;
//步骤0: M2执行获取非分工目标内容下发状态 - implementGainNotDivTargetContIssueState
        //ModelCode: singleDatasetObjMerge
        ImplementGainNotDivTargetContIssueStateRespDto singleDatasetObjMergeRes = null;
        ImplementGainNotDivTargetContIssueStateReqDto singleDatasetObjMergeReq = new ImplementGainNotDivTargetContIssueStateReqDto();
        singleDatasetObjMergeReq.setComTxtField("TRUE");//CUSTOM_CONVENTION//sourceId:597500_1
        if (reqDto != null) {
            singleDatasetObjMergeReq.setSuperiorTargetObjAssistNodeStatusListList(reqDto.getSuperiorTargetObjAssistNodeStatusListList());//list-field-assign//sourceId:597499_1
        }

        /*M2执行获取非分工目标内容下发状态[5642]   */
        Assert.isNull(singleDatasetObjMergeReq.getComTxtField(), "D2执行获取非分工目标内容下发状态(公共)-M2执行获取非分工目标内容下发状态-通用文本字段不能为空", false);
        singleDatasetObjMergeRes = nbInterfaceMode.implementGainNotDivTargetContIssueState(singleDatasetObjMergeReq);


        singleDatasetObjMergeRes_1 = singleDatasetObjMergeRes;

        ImplementGainNotDivTargetContIssueStateComRespDto retData = new ImplementGainNotDivTargetContIssueStateComRespDto();
        if (singleDatasetObjMergeRes_1 != null) {
            retData.setTargetContGainIssueStateList(singleDatasetObjMergeRes_1.getTargetContGainIssueStateList().stream().map(item -> BeanUtil.toBean(item, TargetContGainIssueStateDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:597507_1
        }


        return retData;
    }

    /**
     * D2执行多数据集多字段取交集(公共)[5676]
     * gen by moon at 2/8/2023, 1:49:03 PM
     */
    @Trace(operationName = "D2执行多数据集多字段取交集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUniteMultipleManyFieldsDataSetsComRespDto implementUniteMultipleManyFieldsDataSetsCom(ImplementUniteMultipleManyFieldsDataSetsComReqDto reqDto) {


        ImplementUniteMultipleManyFieldsDataSetsRespDto collectionsIntersectionsDataRes_1 = null;
//步骤0: M2执行多数据集多字段取交集（特殊方法） - implementUniteMultipleManyFieldsDataSets
        //ModelCode: collectionsIntersectionsData
        ImplementUniteMultipleManyFieldsDataSetsRespDto collectionsIntersectionsDataRes = null;
        ImplementUniteMultipleManyFieldsDataSetsReqDto collectionsIntersectionsDataReq = new ImplementUniteMultipleManyFieldsDataSetsReqDto();
        if (reqDto != null && reqDto.getDataSetsListOne() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())) {
            collectionsIntersectionsDataReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:603502_1
        }
        if (reqDto != null && reqDto.getDataSetsListTwo() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())) {
            collectionsIntersectionsDataReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:603503_1
        }

        /*M2执行多数据集多字段取交集（特殊方法）[5675]  入参两个数据集，求两个数据集中共同存在的部分输出 */

        collectionsIntersectionsDataRes = nbInterfaceMode.implementUniteMultipleManyFieldsDataSets(collectionsIntersectionsDataReq);


        collectionsIntersectionsDataRes_1 = collectionsIntersectionsDataRes;

        ImplementUniteMultipleManyFieldsDataSetsComRespDto retData = new ImplementUniteMultipleManyFieldsDataSetsComRespDto();
        if (collectionsIntersectionsDataRes_1 != null) {
            retData.setCollectionsIntersectionsDataList(collectionsIntersectionsDataRes_1.getCollectionsIntersectionsDataList().stream().map(item -> BeanUtil.toBean(item, CollectionsIntersectionsDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:604010_1
        }


        return retData;
    }

    /**
     * D2执行数据集单条多字段列转行(公共)[5724]
     * gen by moon at 1/17/2023, 9:42:09 PM
     */
    @Trace(operationName = "D2执行数据集单条多字段列转行(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataEinzelbandFiltersColumnTurnRowComRespDto implementDataEinzelbandFiltersColumnTurnRowCom(ImplementDataEinzelbandFiltersColumnTurnRowComReqDto reqDto) {


        ImplementDataEinzelbandFiltersColumnTurnRowRespDto columnToRowRes_1 = null;
//步骤0: M2执行数据集单条多字段列转行(特殊方法） - implementDataEinzelbandFiltersColumnTurnRow
        //ModelCode: columnToRow
        ImplementDataEinzelbandFiltersColumnTurnRowRespDto columnToRowRes = null;
        ImplementDataEinzelbandFiltersColumnTurnRowReqDto columnToRowReq = new ImplementDataEinzelbandFiltersColumnTurnRowReqDto();
        if (reqDto != null) {
            columnToRowReq.setDataEinzelbandFiltersColumnTurnRowList(reqDto.getDataEinzelbandFiltersColumnTurnRowList().stream().map(item -> BeanUtil.toBean(item, DataEinzelbandFiltersColumnTurnRowDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:614493_1
        }

        /*M2执行数据集单条多字段列转行(特殊方法）[5723]  将多列数据转成一行数据 */

        columnToRowRes = nbInterfaceMode.implementDataEinzelbandFiltersColumnTurnRow(columnToRowReq);


        columnToRowRes_1 = columnToRowRes;

        ImplementDataEinzelbandFiltersColumnTurnRowComRespDto retData = new ImplementDataEinzelbandFiltersColumnTurnRowComRespDto();
        if (columnToRowRes_1 != null) {
            retData.setCommPrimaryKey(columnToRowRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:614500_1
            retData.setCustomField(columnToRowRes_1.getCustomField());//SimpleFieldAssign//sourceId:614501_1
            retData.setCustomField1(columnToRowRes_1.getCustomField1());//SimpleFieldAssign//sourceId:614502_1
            retData.setCustomField2(columnToRowRes_1.getCustomField2());//SimpleFieldAssign//sourceId:614503_1
            retData.setCustomField3(columnToRowRes_1.getCustomField3());//SimpleFieldAssign//sourceId:614504_1
        }


        return retData;
    }

    /**
     * D2执行数据新增删除分类(公共)[5727]
     * gen by moon at 1/18/2023, 3:24:42 PM
     */
    @Trace(operationName = "D2执行数据新增删除分类(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataAddOrDeleteClassComRespDto implementDataAddOrDeleteClassCom(ImplementDataAddOrDeleteClassComReqDto reqDto) {


        ImplementDataAddOrDeleteClassRespDto dataAuClassificationRes_1 = null;
//步骤0: M2执行数据新增删除分类（特殊方法） - implementDataAddOrDeleteClass
        //ModelCode: dataAuClassification
        ImplementDataAddOrDeleteClassRespDto dataAuClassificationRes = null;
        ImplementDataAddOrDeleteClassReqDto dataAuClassificationReq = new ImplementDataAddOrDeleteClassReqDto();
        if (reqDto != null) {
            dataAuClassificationReq.setDataSetsListOne(reqDto.getDataSetsListOne());//list-field-assign//sourceId:614571_1
            dataAuClassificationReq.setDataSetsListTwo(reqDto.getDataSetsListTwo());//list-field-assign//sourceId:614572_1
        }

        /*M2执行数据新增删除分类（特殊方法）[5728]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */

        dataAuClassificationRes = nbInterfaceMode.implementDataAddOrDeleteClass(dataAuClassificationReq);


        dataAuClassificationRes_1 = dataAuClassificationRes;

        ImplementDataAddOrDeleteClassComRespDto retData = new ImplementDataAddOrDeleteClassComRespDto();
        if (dataAuClassificationRes_1 != null) {
            retData.setAwaitAddClassDataList(dataAuClassificationRes_1.getAwaitAddClassDataList());//list-field-assign//sourceId:614577_1
            retData.setAwaitDeleteClassDataList(dataAuClassificationRes_1.getAwaitDeleteClassDataList());//list-field-assign//sourceId:614578_1
        }


        return retData;
    }

    /**
     * D2-执行字符串对比(公共)[5774]
     * gen by moon at 5/9/2023, 5:19:41 AM
     */
    @Trace(operationName = "D2-执行字符串对比(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckCom(ImplementStringEfficiencyCheckComReqDto reqDto) {


        ImplementStringEfficiencyCheckRespDto stringEfficiencyCheckRes_1 = null;
//步骤0: M2-执行字符串对比（特殊方法） - implementStringEfficiencyCheck
        //ModelCode: stringEfficiencyCheck
        ImplementStringEfficiencyCheckRespDto stringEfficiencyCheckRes = null;
        ImplementStringEfficiencyCheckReqDto stringEfficiencyCheckReq = new ImplementStringEfficiencyCheckReqDto();
        if (reqDto != null) {
            stringEfficiencyCheckReq.setReferenceString(reqDto.getReferenceString());//SimpleFieldAssign//sourceId:627983_1
            stringEfficiencyCheckReq.setComparisonString(reqDto.getComparisonString());//SimpleFieldAssign//sourceId:627984_1
        }

        /*M2-执行字符串对比（特殊方法）[3423]  入参末级周期类型标识（参照字符串），当前周期类型标识（比对字符串），如果对比字符串等于参照字符串，则返回TRUE，否则返回FALSE */

        stringEfficiencyCheckRes = nbInterfaceMode.implementStringEfficiencyCheck(stringEfficiencyCheckReq);


        stringEfficiencyCheckRes_1 = stringEfficiencyCheckRes;

        ImplementStringEfficiencyCheckComRespDto retData = new ImplementStringEfficiencyCheckComRespDto();
        if (stringEfficiencyCheckRes_1 != null) {
            retData.setStringEfficiencyCheckResult(stringEfficiencyCheckRes_1.getStringEfficiencyCheckResult());//SimpleFieldAssign//sourceId:627988_1
        }


        return retData;
    }

    /**
     * D2-执行多条转数据集(公共)[5869]
     * gen by moon at 2/8/2023, 2:21:06 PM
     */
    @Trace(operationName = "D2-执行多条转数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMulitDataToOneDatasComRespDto implementMulitDataToOneDatasCom(ImplementMulitDataToOneDatasComReqDto reqDto) {


        ImplementMulitDataToOneDatasRespDto objectToDataRes_1 = null;
//步骤0: M2-执行多字段转数据集（特殊方法） - implementMulitDataToOneDatas
        //ModelCode: objectToData
        ImplementMulitDataToOneDatasRespDto objectToDataRes = null;
        ImplementMulitDataToOneDatasReqDto objectToDataReq = new ImplementMulitDataToOneDatasReqDto();
        if (reqDto != null) {
            objectToDataReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:657425_1
            objectToDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:657426_1
            objectToDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:657427_1
            objectToDataReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:657428_1
            objectToDataReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:657799_1
            objectToDataReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:657800_1
        }

        /*M2-执行多字段转数据集（特殊方法）[5868]  用于周期阶段资料内容中查询的多个图片信息，数据库中一个字段中的信息将转换到多张图片信息的地址（数据集）供前端展示 */

        objectToDataRes = nbInterfaceMode.implementMulitDataToOneDatas(objectToDataReq);


        objectToDataRes_1 = objectToDataRes;

        ImplementMulitDataToOneDatasComRespDto retData = new ImplementMulitDataToOneDatasComRespDto();
        if (objectToDataRes_1 != null) {
            retData.setMulitDataToOneDatasList(objectToDataRes_1.getMulitDataToOneDatasList().stream().map(item -> BeanUtil.toBean(item, MulitDataToOneDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:657434_1
        }


        return retData;
    }

    /**
     * D2执行根据排序左右切数据(公共)[5866]
     * gen by moon at 2/10/2023, 9:43:07 PM
     */
    @Trace(operationName = "D2执行根据排序左右切数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSplitDataBySortComRespDto implementSplitDataBySortCom(ImplementSplitDataBySortComReqDto reqDto) {


        ImplementSplitDataBySortRespDto findTargetDataByIntervalDataRes_1 = null;
//步骤0: M2执行根据排序左右切数据（特殊方法） - implementSplitDataBySort
        //ModelCode: findTargetDataByIntervalData
        ImplementSplitDataBySortRespDto findTargetDataByIntervalDataRes = null;
        ImplementSplitDataBySortReqDto findTargetDataByIntervalDataReq = new ImplementSplitDataBySortReqDto();
        if (reqDto != null) {
            findTargetDataByIntervalDataReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:660492_1
            findTargetDataByIntervalDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:660493_1
            findTargetDataByIntervalDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:660494_1
        }

    /*M2执行根据排序左右切数据（特殊方法）[5865]  入参数据集+单字段数值+大小策略。出参数据集中满足条件的单条数据
单字段数值跟数据集中同名字段对比，根据策略（向上找大或向下找小）找到数据集中的记录。
举例：数据集里面有60，及格；70，一般；80，中等；90，良好；100，优秀
数据集集外的单字段是87，策略：向上找大
目的就是根据入参的单字段，到数据集里面找所在的数据区间，如果落在了80中等~90良好区间，则返回90良好 */
        Assert.isNull(findTargetDataByIntervalDataReq.getCustomField1(), "D2执行根据排序左右切数据(公共)-M2执行根据排序左右切数据（特殊方法）-自定义字段1不能为空", false);
        Assert.isNull(findTargetDataByIntervalDataReq.getCustomField2(), "D2执行根据排序左右切数据(公共)-M2执行根据排序左右切数据（特殊方法）-自定义字段2不能为空", false);
        findTargetDataByIntervalDataRes = nbInterfaceMode.implementSplitDataBySort(findTargetDataByIntervalDataReq);


        findTargetDataByIntervalDataRes_1 = findTargetDataByIntervalDataRes;

        ImplementSplitDataBySortComRespDto retData = new ImplementSplitDataBySortComRespDto();
        if (findTargetDataByIntervalDataRes_1 != null) {
            retData.setComDatasList(findTargetDataByIntervalDataRes_1.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:657131_1
        }


        return retData;
    }

    /**
     * D2执行截取字符串保留前N个字符(公共)[5878]
     * gen by moon at 10/5/2023, 2:21:11 PM
     */
    @Trace(operationName = "D2执行截取字符串保留前N个字符(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCutRetainStringComRespDto implementCutRetainStringCom(ImplementCutRetainStringComReqDto reqDto) {


        QueryCutRetainStringDetailRespDto cutStringRes_1 = null;
//步骤0: M2截取字符串保留前N个字符（特殊方法） - queryCutRetainStringDetail
        //ModelCode: cutString
        QueryCutRetainStringDetailRespDto cutStringRes = null;
        QueryCutRetainStringDetailReqDto cutStringReq = new QueryCutRetainStringDetailReqDto();
        if (reqDto != null) {
            cutStringReq.setOriginalString(reqDto.getOriginalString());//SimpleFieldAssign//sourceId:660978_1
            cutStringReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:1162330_1
        }

        /*M2截取字符串保留前N个字符（特殊方法）[5877]  入参字符串A，数值B。用于从字符串A中截取前B个字符 */
        Assert.isNull(cutStringReq.getOriginalString(), "D2执行截取字符串保留前N个字符(公共)-M2截取字符串保留前N个字符（特殊方法）-原字符串不能为空", false);
        Assert.isNull(cutStringReq.getComNumField(), "D2执行截取字符串保留前N个字符(公共)-M2截取字符串保留前N个字符（特殊方法）-通用数值字段（整数型）不能为空", false);
        cutStringRes = nbInterfaceMode.queryCutRetainStringDetail(cutStringReq);


        cutStringRes_1 = cutStringRes;

        ImplementCutRetainStringComRespDto retData = new ImplementCutRetainStringComRespDto();
        if (cutStringRes_1 != null) {
            retData.setCutString(cutStringRes_1.getCutString());//SimpleFieldAssign//sourceId:660982_1
        }


        return retData;
    }

    /**
     * D2执行多条转数据集(公共)[5864]
     * gen by moon at 5/21/2024, 11:18:19 PM
     */
    @Trace(operationName = "D2执行多条转数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMutDataToOneDatasComRespDto implementMutDataToOneDatasCom(ImplementMutDataToOneDatasComReqDto reqDto) {


        ImplementMutDataToOneDatasRespDto objectToDataRes_1 = null;
//步骤0: M2执行多条转数据集（特殊方法） - implementMutDataToOneDatas
        //ModelCode: objectToData
        ImplementMutDataToOneDatasRespDto objectToDataRes = null;
        ImplementMutDataToOneDatasReqDto objectToDataReq = new ImplementMutDataToOneDatasReqDto();
        if (reqDto != null) {
            objectToDataReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:717755_1
            objectToDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:657040_1
            objectToDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:657041_1
            objectToDataReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:657042_1
            objectToDataReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:701717_1
            objectToDataReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:701718_1
            objectToDataReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:701719_1
            objectToDataReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:701720_1
            objectToDataReq.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:701721_1
            objectToDataReq.setCustomField9(reqDto.getCustomField9());//SimpleFieldAssign//sourceId:1812218_1
            objectToDataReq.setCustomField10(reqDto.getCustomField10());//SimpleFieldAssign//sourceId:1812219_1
            objectToDataReq.setCustomField11(reqDto.getCustomField11());//SimpleFieldAssign//sourceId:1812220_1
            objectToDataReq.setCustomField12(reqDto.getCustomField12());//SimpleFieldAssign//sourceId:1812221_1
            objectToDataReq.setCustomField13(reqDto.getCustomField13());//SimpleFieldAssign//sourceId:1812222_1
            objectToDataReq.setCustomField14(reqDto.getCustomField14());//SimpleFieldAssign//sourceId:1812223_1
            objectToDataReq.setCustomField15(reqDto.getCustomField15());//SimpleFieldAssign//sourceId:1812224_1
            objectToDataReq.setCustomField16(reqDto.getCustomField16());//SimpleFieldAssign//sourceId:1812225_1
        }

        /*M2执行多条转数据集（特殊方法）[5863]  用于周期阶段资料内容中查询的多个图片信息，数据库中一个字段中的信息将转换到多张图片信息的地址（数据集）供前端展示 */

        objectToDataRes = nbInterfaceMode.implementMutDataToOneDatas(objectToDataReq);


        objectToDataRes_1 = objectToDataRes;

        ImplementMutDataToOneDatasComRespDto retData = new ImplementMutDataToOneDatasComRespDto();
        if (objectToDataRes_1 != null) {
            retData.setComDatasList(objectToDataRes_1.getComDatasList());//list-field-assign//sourceId:657047_1
        }


        return retData;
    }

    /**
     * D2执行文档数据集插入排序字段(公共)[6063]
     * gen by moon at 3/11/2023, 3:58:12 PM
     */
    @Trace(operationName = "D2执行文档数据集插入排序字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDocDataSetInsertionOrderNumComRespDto implementDocDataSetInsertionOrderNumCom(ImplementDocDataSetInsertionOrderNumComReqDto reqDto) {


        ImplementDocDataSetInsertionOrderNumRespDto docDataSetInsertionOrderNumRes_1 = null;
//步骤0: M2执行文档数据集插入排序字段 - implementDocDataSetInsertionOrderNum
        //ModelCode: docDataSetInsertionOrderNum
        ImplementDocDataSetInsertionOrderNumRespDto docDataSetInsertionOrderNumRes = null;
        ImplementDocDataSetInsertionOrderNumReqDto docDataSetInsertionOrderNumReq = new ImplementDocDataSetInsertionOrderNumReqDto();
        if (reqDto != null && reqDto.getDocumentList() != null && !CollectionUtil.isEmpty(reqDto.getDocumentList())) {
            docDataSetInsertionOrderNumReq.setDocumentList(reqDto.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743730_1
        }

        /*M2执行文档数据集插入排序字段[6062]  个性模式：仅用于文档的数据集数据插入排序字段值 */

        docDataSetInsertionOrderNumRes = nbInterfaceMode.implementDocDataSetInsertionOrderNum(docDataSetInsertionOrderNumReq);


        docDataSetInsertionOrderNumRes_1 = docDataSetInsertionOrderNumRes;

        ImplementDocDataSetInsertionOrderNumComRespDto retData = new ImplementDocDataSetInsertionOrderNumComRespDto();
        if (docDataSetInsertionOrderNumRes_1 != null) {
            retData.setDocumentList(docDataSetInsertionOrderNumRes_1.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743733_1
        }


        return retData;
    }

    /**
     * D2执行数据集合并文档关系字段(公共)[6065]
     * gen by moon at 3/11/2023, 3:34:27 PM
     */
    @Trace(operationName = "D2执行数据集合并文档关系字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetMergeDocRelationFieldsComRespDto implementDataSetMergeDocRelationFieldsCom(ImplementDataSetMergeDocRelationFieldsComReqDto reqDto) {


        ImplementDataSetMergeDocRelationFieldsComRespDto dataSetMergeDocRelationFieldsRes_1 = null;
//步骤0: M2执行数据集合并文档关系字段(公共) - implementDataSetMergeDocRelationFieldsCom
        //ModelCode: dataSetMergeDocRelationFields
        ImplementDataSetMergeDocRelationFieldsComRespDto dataSetMergeDocRelationFieldsRes = null;
        ImplementDataSetMergeDocRelationFieldsComReqDto dataSetMergeDocRelationFieldsReq = new ImplementDataSetMergeDocRelationFieldsComReqDto();
        if (reqDto != null && reqDto.getDocumentList() != null && !CollectionUtil.isEmpty(reqDto.getDocumentList())) {
            dataSetMergeDocRelationFieldsReq.setDocumentList(reqDto.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743739_1
        }
        if (reqDto != null && reqDto.getDataSetsListOne() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())) {
            dataSetMergeDocRelationFieldsReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743740_1
        }

        /*M2执行数据集合并文档关系字段(公共)[6064]  个性模式：仅用于文档数据集合并文档关系数据集中的字段 */

        dataSetMergeDocRelationFieldsRes = nbInterfaceMode.implementDataSetMergeDocRelationFieldsCom(dataSetMergeDocRelationFieldsReq);


        dataSetMergeDocRelationFieldsRes_1 = dataSetMergeDocRelationFieldsRes;

        ImplementDataSetMergeDocRelationFieldsComRespDto retData = new ImplementDataSetMergeDocRelationFieldsComRespDto();
        if (dataSetMergeDocRelationFieldsRes_1 != null) {
            retData.setDocumentList(dataSetMergeDocRelationFieldsRes_1.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:743744_1
        }


        return retData;
    }

    /**
     * D2执行多数据集字段合并(公共)[6214]
     * gen by moon at 4/2/2023, 9:50:56 PM
     */
    @Trace(operationName = "D2执行多数据集字段合并(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementManyDataSetFieldsMergeComRespDto implementManyDataSetFieldsMergeCom(ImplementManyDataSetFieldsMergeComReqDto reqDto) {


        ImplementManyDataSetFieldsMergeRespDto manyDataSetFieldsMergeRes_1 = null;
//步骤0: M2执行多数据集字段合并（特殊方法） - implementManyDataSetFieldsMerge
        //ModelCode: manyDataSetFieldsMerge
        ImplementManyDataSetFieldsMergeRespDto manyDataSetFieldsMergeRes = null;
        ImplementManyDataSetFieldsMergeReqDto manyDataSetFieldsMergeReq = new ImplementManyDataSetFieldsMergeReqDto();
        if (reqDto != null && reqDto.getDataSetsListOne() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())) {
            manyDataSetFieldsMergeReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:809141_1
        }
        if (reqDto != null && reqDto.getDataSetsListTwo() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())) {
            manyDataSetFieldsMergeReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:809142_1
        }

        /*M2执行多数据集字段合并（特殊方法）[6213]  用于2个以上的数据集多字段合并成一个数据集并出参 */

        manyDataSetFieldsMergeRes = nbInterfaceMode.implementManyDataSetFieldsMerge(manyDataSetFieldsMergeReq);


        manyDataSetFieldsMergeRes_1 = manyDataSetFieldsMergeRes;

        ImplementManyDataSetFieldsMergeComRespDto retData = new ImplementManyDataSetFieldsMergeComRespDto();
        if (manyDataSetFieldsMergeRes_1 != null) {
            retData.setMergeFieldsList(manyDataSetFieldsMergeRes_1.getMergeFieldsList().stream().map(item -> BeanUtil.toBean(item, MergeFieldsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:809146_1
        }


        return retData;
    }

    /**
     * D2-执行标准时间转换为字符串(公共)[6274]
     * gen by moon at 4/15/2023, 1:05:18 AM
     */
    @Trace(operationName = "D2-执行标准时间转换为字符串(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTimeTurnToStringComRespDto implementTimeTurnToStringCom(ImplementTimeTurnToStringComReqDto reqDto) {


        ImplementTimeTurnToStringRespDto timeTurnToStringRes_1 = null;
//步骤0: M2-执行标准时间转换为字符串（特殊接口） - implementTimeTurnToString
        //ModelCode: timeTurnToString
        ImplementTimeTurnToStringRespDto timeTurnToStringRes = null;
        ImplementTimeTurnToStringReqDto timeTurnToStringReq = new ImplementTimeTurnToStringReqDto();
        if (reqDto != null) {
            timeTurnToStringReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:822169_1
        }

        /*M2-执行标准时间转换为字符串（特殊接口）[6273]  入参标准时间字段2022-09-02 23:00:09，将时间字段转换为字符串20220902230009 */

        timeTurnToStringRes = nbInterfaceMode.implementTimeTurnToString(timeTurnToStringReq);


        timeTurnToStringRes_1 = timeTurnToStringRes;

        ImplementTimeTurnToStringComRespDto retData = new ImplementTimeTurnToStringComRespDto();
        if (timeTurnToStringRes_1 != null) {
            retData.setComTxtField(timeTurnToStringRes_1.getComTxtField());//SimpleFieldAssign//sourceId:822172_1
        }


        return retData;
    }

    /**
     * D2执行找祖先标识(公共)[6307]
     * gen by moon at 4/17/2023, 11:49:41 PM
     */
    @Trace(operationName = "D2执行找祖先标识(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLookAncestorNodeCodeComRespDto implementLookAncestorNodeCodeCom(ImplementLookAncestorNodeCodeComReqDto reqDto) {


        QueryLookAncestorNodeCodeListRespDto findAllLevelCodeListRes_1 = null;
//步骤0: M2-查找祖先标识列表(特殊方法） - queryLookAncestorNodeCodeList
        //ModelCode: findAllLevelCodeList
        QueryLookAncestorNodeCodeListRespDto findAllLevelCodeListRes = null;
        QueryLookAncestorNodeCodeListReqDto findAllLevelCodeListReq = new QueryLookAncestorNodeCodeListReqDto();
        if (reqDto != null) {
            findAllLevelCodeListReq.setComCode(reqDto.getComCode());//SimpleFieldAssign//sourceId:837246_1
        }

        /*M2-查找祖先标识列表(特殊方法）[6308]  找入参条件的所有层级列表 */
        Assert.isNull(findAllLevelCodeListReq.getComCode(), "D2执行找祖先标识(公共)-M2-查找祖先标识列表(特殊方法）-通用编码标识不能为空", false);
        findAllLevelCodeListRes = nbInterfaceMode.queryLookAncestorNodeCodeList(findAllLevelCodeListReq);


        findAllLevelCodeListRes_1 = findAllLevelCodeListRes;

        ImplementLookAncestorNodeCodeComRespDto retData = new ImplementLookAncestorNodeCodeComRespDto();
        if (findAllLevelCodeListRes_1 != null) {
            retData.setLookAncestorNodeList(findAllLevelCodeListRes_1.getLookAncestorNodeList());//list-field-assign//sourceId:837248_1
        }


        return retData;
    }

    /**
     * D2执行两个值比较是否相等(公共)[6425]
     * gen by moon at 9/25/2023, 10:44:42 AM
     */
    @Trace(operationName = "D2执行两个值比较是否相等(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTwoValuesIsEqualityComRespDto implementTwoValuesIsEqualityCom(ImplementTwoValuesIsEqualityComReqDto reqDto) {


        ImplementTwoValuesIsEqualityRespDto twoValuesIsEqualityRes_1 = null;
//步骤0: M2执行两个值比较是否相等(特殊方法） - implementTwoValuesIsEquality
        //ModelCode: twoValuesIsEquality
        ImplementTwoValuesIsEqualityRespDto twoValuesIsEqualityRes = null;
        ImplementTwoValuesIsEqualityReqDto twoValuesIsEqualityReq = new ImplementTwoValuesIsEqualityReqDto();
        if (reqDto != null) {
            twoValuesIsEqualityReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:879693_1
            twoValuesIsEqualityReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:879694_1
        }

        /*M2执行两个值比较是否相等(特殊方法）[6427]  用于比较两个字段值是否相同 */

        twoValuesIsEqualityRes = nbInterfaceMode.implementTwoValuesIsEquality(twoValuesIsEqualityReq);


        twoValuesIsEqualityRes_1 = twoValuesIsEqualityRes;

        ImplementTwoValuesIsEqualityComRespDto retData = new ImplementTwoValuesIsEqualityComRespDto();
        if (twoValuesIsEqualityRes_1 != null) {
            retData.setTureOrFalse(twoValuesIsEqualityRes_1.getTureOrFalse());//SimpleFieldAssign//sourceId:879698_1
        }


        return retData;
    }

    /**
     * D2-执行周期合并(公共)[6506]
     * gen by moon at 5/28/2023, 11:13:44 PM
     */
    @Trace(operationName = "D2-执行周期合并(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExcCycleSetFieldsMergeComRespDto implementExcCycleSetFieldsMergeCom(ImplementExcCycleSetFieldsMergeComReqDto reqDto) {


        ImplementExcCycleSetFieldsMergeRespDto collectionsMergeDataRes_1 = null;
//步骤0: M2-执行周期合并（特殊方法） - implementExcCycleSetFieldsMerge
        //ModelCode: collectionsMergeData
        ImplementExcCycleSetFieldsMergeRespDto collectionsMergeDataRes = null;
        ImplementExcCycleSetFieldsMergeReqDto collectionsMergeDataReq = new ImplementExcCycleSetFieldsMergeReqDto();
        if (reqDto != null) {
            collectionsMergeDataReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:902142_1
            collectionsMergeDataReq.setExcCycleSetFieldsMergeList(reqDto.getExcCycleSetFieldsMergeList().stream().map(item -> BeanUtil.toBean(item, ExcCycleSetFieldsMergeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:902144_1
        }

        /*M2-执行周期合并（特殊方法）[6505]  入参多个数据集，取并集 */

        collectionsMergeDataRes = nbInterfaceMode.implementExcCycleSetFieldsMerge(collectionsMergeDataReq);


        collectionsMergeDataRes_1 = collectionsMergeDataRes;

        ImplementExcCycleSetFieldsMergeComRespDto retData = new ImplementExcCycleSetFieldsMergeComRespDto();
        if (collectionsMergeDataRes_1 != null) {
            retData.setExecuteCycleStageList(collectionsMergeDataRes_1.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:902145_1
        }


        return retData;
    }

    /**
     * D2执行接收数据集出参(公共)[6523]
     * gen by moon at 5/8/2023, 6:57:20 AM
     */
    @Trace(operationName = "D2执行接收数据集出参(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAcceptDataSetOutputComRespDto implementAcceptDataSetOutputCom(ImplementAcceptDataSetOutputComReqDto reqDto) {


        ImplementAcceptDataSetOutputRespDto receptionServiceRes_1 = null;
//步骤0: M2执行接收数据集出参（特殊方法） - implementAcceptDataSetOutput
        //ModelCode: receptionService
        ImplementAcceptDataSetOutputRespDto receptionServiceRes = null;
        ImplementAcceptDataSetOutputReqDto receptionServiceReq = new ImplementAcceptDataSetOutputReqDto();
        if (reqDto != null) {
            receptionServiceReq.setAcceptDataSetOutputList(//objList-to-objLists
                    reqDto.getAcceptDataSetOutputList().stream().map(item -> {
                        AcceptDataSetOutputDto elm = new AcceptDataSetOutputDto();
                        if (item != null) {
                            elm.setApplexRelId(item.getApplexRelId());//SimpleFieldAssign//sourceId:193292_2
                            elm.setApplexType(item.getApplObjType());//SimpleFieldAssign//sourceId:193293_2
                            elm.setApplexId(item.getApplexId());//SimpleFieldAssign//sourceId:193294_2
                            elm.setObjectName(item.getObjectName());//SimpleFieldAssign//sourceId:193295_2
                        }
                        return elm;
                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:904148_1
        }

        /*M2执行接收数据集出参（特殊方法）[6522]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbInterfaceMode.implementAcceptDataSetOutput(receptionServiceReq);


        receptionServiceRes_1 = receptionServiceRes;

        ImplementAcceptDataSetOutputComRespDto retData = new ImplementAcceptDataSetOutputComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setAcceptDataSetOutputList(//objList-to-objLists
                    receptionServiceRes_1.getAcceptDataSetOutputList().stream().map(item -> {
                        AcceptDataSetOutputDto elm = new AcceptDataSetOutputDto();
                        if (item != null) {
                            elm.setApplexRelId(item.getApplexRelId());//SimpleFieldAssign//sourceId:193300_2
                            elm.setApplObjType(item.getApplexType());//SimpleFieldAssign//sourceId:193301_2
                            elm.setApplexId(item.getApplexId());//SimpleFieldAssign//sourceId:193302_2
                            elm.setObjectName(item.getObjectName());//SimpleFieldAssign//sourceId:193303_2
                        }
                        return elm;
                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:904151_1
        }


        return retData;
    }

    /**
     * D2查询整数型变量详情(公共)[6531]
     * gen by moon at 1/21/2024, 9:48:13 PM
     */
    @Trace(operationName = "D2查询整数型变量详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryIntegerVariableDetailComRespDto queryIntegerVariableDetailCom(QueryIntegerVariableDetailComReqDto reqDto) {


        ObtainReceiveFieldsRespDto receptionServiceRes_1 = null;
//步骤0: M2获取接收字段 - obtainReceiveFields
        //ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes = null;
        ObtainReceiveFieldsReqDto receptionServiceReq = new ObtainReceiveFieldsReqDto();
        if (reqDto != null) {
            receptionServiceReq.setObjectName(reqDto.getObjectName());//SimpleFieldAssign//sourceId:1110530_1
            receptionServiceReq.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1475848_1
            receptionServiceReq.setChannelName(reqDto.getChannelName());//SimpleFieldAssign//sourceId:1110531_1
            receptionServiceReq.setChannelLogo(reqDto.getChannelLogo());//SimpleFieldAssign//sourceId:1110532_1
            receptionServiceReq.setNewTableTypeCode(reqDto.getNewTableTypeCode());//SimpleFieldAssign//sourceId:1110533_1
            receptionServiceReq.setNewEntityId(reqDto.getNewEntityId());//SimpleFieldAssign//sourceId:1110534_1
            receptionServiceReq.setConTableTypeCode(reqDto.getConTableTypeCode());//SimpleFieldAssign//sourceId:1442572_1
            receptionServiceReq.setConEntityId(reqDto.getConEntityId());//SimpleFieldAssign//sourceId:1442573_1
            receptionServiceReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:908034_1
            receptionServiceReq.setMessageTemplateCode(reqDto.getMessageTemplateCode());//SimpleFieldAssign//sourceId:1108762_1
            receptionServiceReq.setUseChannelMethod(reqDto.getUseChannelMethod());//SimpleFieldAssign//sourceId:1102390_1
            receptionServiceReq.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1110535_1
            receptionServiceReq.setChannelAppCliqueType(reqDto.getChannelAppCliqueType());//SimpleFieldAssign//sourceId:1442101_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1110536_1
            receptionServiceReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1442583_1
            receptionServiceReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1442632_1
            receptionServiceReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1442633_1
            receptionServiceReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1442652_1
            receptionServiceReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1442619_1
            receptionServiceReq.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1442606_1
            receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1442607_1
            receptionServiceReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:1443710_1
            receptionServiceReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:1443711_1
            receptionServiceReq.setMediaType(reqDto.getMediaType());//SimpleFieldAssign//sourceId:1442884_1
            receptionServiceReq.setMediaAddress(reqDto.getMediaAddress());//SimpleFieldAssign//sourceId:1442885_1
            receptionServiceReq.setCooperateContentTypeCode(reqDto.getCooperateContentTypeCode());//SimpleFieldAssign//sourceId:1442881_1
            receptionServiceReq.setCooperateContentId(reqDto.getCooperateContentId());//SimpleFieldAssign//sourceId:1442882_1
            receptionServiceReq.setSurfaceContName(reqDto.getSurfaceContName());//SimpleFieldAssign//sourceId:1442883_1
            receptionServiceReq.setReferenceMessageId(reqDto.getReferenceMessageId());//SimpleFieldAssign//sourceId:1442614_1
            receptionServiceReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:1494127_1
            receptionServiceReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:1494128_1
        }

        /*M2获取接收字段[4007]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);


        receptionServiceRes_1 = receptionServiceRes;

        QueryIntegerVariableDetailComRespDto retData = new QueryIntegerVariableDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setComNumField(receptionServiceRes_1.getComNumField());//SimpleFieldAssign//sourceId:908038_1
            retData.setUseChannelMethod(receptionServiceRes_1.getUseChannelMethod());//SimpleFieldAssign//sourceId:1102394_1
            retData.setMessageTemplateCode(receptionServiceRes_1.getMessageTemplateCode());//SimpleFieldAssign//sourceId:1108771_1
            retData.setCustomField(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:1442623_1
            retData.setCustomField1(receptionServiceRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1442636_1
            retData.setCustomField2(receptionServiceRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1442637_1
            retData.setCustomField3(receptionServiceRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1442655_1
            retData.setCustomField4(receptionServiceRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1443716_1
            retData.setCustomField5(receptionServiceRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1443717_1
            retData.setCustomField6(receptionServiceRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1494134_1
            retData.setCustomField7(receptionServiceRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1494135_1
            retData.setNewTableTypeCode(receptionServiceRes_1.getNewTableTypeCode());//SimpleFieldAssign//sourceId:1442692_1
            retData.setConTableTypeCode(receptionServiceRes_1.getConTableTypeCode());//SimpleFieldAssign//sourceId:1442691_1
        }


        return retData;
    }

    /**
     * D2获取输出当前标识(公共)[6786]
     * gen by moon at 5/16/2023, 8:56:35 PM
     */
    @Trace(operationName = "D2获取输出当前标识(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainOutPutCurrentCodeComRespDto obtainOutPutCurrentCodeCom(ObtainOutPutCurrentCodeComReqDto reqDto) {


        ObtainOutPutCurrentCodeRespDto getCurrentContentCodeRes_1 = null;
//步骤0: M2获取输出当前标识 - obtainOutPutCurrentCode
        //ModelCode: getCurrentContentCode
        ObtainOutPutCurrentCodeRespDto getCurrentContentCodeRes = null;
        ObtainOutPutCurrentCodeReqDto getCurrentContentCodeReq = new ObtainOutPutCurrentCodeReqDto();
        if (reqDto != null) {
            getCurrentContentCodeReq.setComCode1(reqDto.getComCode1());//SimpleFieldAssign//sourceId:948845_1
            getCurrentContentCodeReq.setSiblingCodeList(reqDto.getSiblingCodeList());//list-field-assign//sourceId:948846_1
        }

        /*M2获取输出当前标识[6784]  用于新建内容时，获取当前层级内容标识。如新增空间、新增指标。入参上级标识CODE，当前层级所有标识CODE，获取本次新增内容的标识CODE */

        getCurrentContentCodeRes = nbInterfaceMode.obtainOutPutCurrentCode(getCurrentContentCodeReq);


        getCurrentContentCodeRes_1 = getCurrentContentCodeRes;

        ObtainOutPutCurrentCodeComRespDto retData = new ObtainOutPutCurrentCodeComRespDto();
        if (getCurrentContentCodeRes_1 != null) {
            retData.setComCode(getCurrentContentCodeRes_1.getComCode());//SimpleFieldAssign//sourceId:948850_1
        }


        return retData;
    }

    /**
     * D2-根据开始时间结束时间计算双周(公共)[6978]
     * gen by moon at 6/24/2023, 10:29:07 PM
     */
    @Trace(operationName = "D2-根据开始时间结束时间计算双周(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCalcDoubleWeekByTimeRangeComRespDto implementCalcDoubleWeekByTimeRangeCom(ImplementCalcDoubleWeekByTimeRangeComReqDto reqDto) {


        ImplementCalcDoubleWeekByTimeRangeRespDto calcDoubleWeekByTimeRangeRes_1 = null;
//步骤0: M2-执根据开始结束时间计算双周（特殊方法） - implementCalcDoubleWeekByTimeRange
        //ModelCode: calcDoubleWeekByTimeRange
        ImplementCalcDoubleWeekByTimeRangeRespDto calcDoubleWeekByTimeRangeRes = null;
        ImplementCalcDoubleWeekByTimeRangeReqDto calcDoubleWeekByTimeRangeReq = new ImplementCalcDoubleWeekByTimeRangeReqDto();
        if (reqDto != null) {
            calcDoubleWeekByTimeRangeReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:987968_1
            calcDoubleWeekByTimeRangeReq.setCycleIsCutHeadAndTail(reqDto.getCycleIsCutHeadAndTail());//SimpleFieldAssign//sourceId:1058694_1
            calcDoubleWeekByTimeRangeReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:987969_1
            calcDoubleWeekByTimeRangeReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:987970_1
        }

        /*M2-执根据开始结束时间计算双周（特殊方法）[6977]  入参开始时间A，结束时间B，双周开始第一天，三个时间点，计算AB两个时间点间所有双周周期列表 */
        Assert.isNull(calcDoubleWeekByTimeRangeReq.getComTimeField(), "D2-根据开始时间结束时间计算双周(公共)-M2-执根据开始结束时间计算双周（特殊方法）-通用时间字段不能为空", false);
        Assert.isNull(calcDoubleWeekByTimeRangeReq.getCycleStartTime(), "D2-根据开始时间结束时间计算双周(公共)-M2-执根据开始结束时间计算双周（特殊方法）-周期开始时间不能为空", false);
        Assert.isNull(calcDoubleWeekByTimeRangeReq.getCycleEndTime(), "D2-根据开始时间结束时间计算双周(公共)-M2-执根据开始结束时间计算双周（特殊方法）-周期结束时间不能为空", false);
        calcDoubleWeekByTimeRangeRes = nbInterfaceMode.implementCalcDoubleWeekByTimeRange(calcDoubleWeekByTimeRangeReq);


        calcDoubleWeekByTimeRangeRes_1 = calcDoubleWeekByTimeRangeRes;

        ImplementCalcDoubleWeekByTimeRangeComRespDto retData = new ImplementCalcDoubleWeekByTimeRangeComRespDto();
        if (calcDoubleWeekByTimeRangeRes_1 != null) {
            retData.setDoubleWeekList(calcDoubleWeekByTimeRangeRes_1.getDoubleWeekList().stream().map(item -> BeanUtil.toBean(item, DoubleWeekDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:987981_1
        }


        return retData;
    }

    /**
     * D2执行清洗物理文件(公共)[7200]
     * gen by moon at 6/11/2023, 9:27:21 PM
     */
    @Trace(operationName = "D2执行清洗物理文件(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCleaningPhysicalFilesComRespDto implementCleaningPhysicalFilesCom(ImplementCleaningPhysicalFilesComReqDto reqDto) {


        //步骤0: M2执行清洗物理文件(特殊方法) - implementCleaningPhysicalFiles
        //ModelCode: cleaningPhysicalFiles
        ImplementCleaningPhysicalFilesRespDto cleaningPhysicalFilesRes = null;
        ImplementCleaningPhysicalFilesReqDto cleaningPhysicalFilesReq = new ImplementCleaningPhysicalFilesReqDto();
        if (reqDto != null) {
            cleaningPhysicalFilesReq.setCleaningPhysicalFilesList(reqDto.getCleaningPhysicalFilesList());//list-field-assign//sourceId:1035864_1
        }

        /*M2执行清洗物理文件(特殊方法)[7199]   */

        cleaningPhysicalFilesRes = nbInterfaceMode.implementCleaningPhysicalFiles(cleaningPhysicalFilesReq);


        ImplementCleaningPhysicalFilesComRespDto retData = new ImplementCleaningPhysicalFilesComRespDto();


        return retData;
    }

    /**
     * D2执行数据集差集(公共)[7197]
     * gen by moon at 6/12/2023, 11:21:29 AM
     */
    @Trace(operationName = "D2执行数据集差集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCollectionsDiffComRespDto implementCollectionsDiffCom(ImplementCollectionsDiffComReqDto reqDto) {


        ImplementCollectionsDiffRespDto getCollectionsDiffRes_1 = null;
//步骤0: M2执行数据集差集 - implementCollectionsDiff
        //ModelCode: getCollectionsDiff
        ImplementCollectionsDiffRespDto getCollectionsDiffRes = null;
        ImplementCollectionsDiffReqDto getCollectionsDiffReq = new ImplementCollectionsDiffReqDto();
        if (reqDto != null) {
            getCollectionsDiffReq.setCollectionsDiffComFatList(reqDto.getCollectionsDiffComFatList());//list-field-assign//sourceId:1035806_1
            getCollectionsDiffReq.setCollectionsDiffComSubList(reqDto.getCollectionsDiffComSubList());//list-field-assign//sourceId:1035807_1
        }

        /*M2执行数据集差集[7196]  对比数据集一，数据二，返回数据集一中有，但数据集二中不存在的数据 */

        getCollectionsDiffRes = nbInterfaceMode.implementCollectionsDiff(getCollectionsDiffReq);


        getCollectionsDiffRes_1 = getCollectionsDiffRes;

        ImplementCollectionsDiffComRespDto retData = new ImplementCollectionsDiffComRespDto();
        if (getCollectionsDiffRes_1 != null) {
            retData.setCollectionsDiffList(getCollectionsDiffRes_1.getCollectionsDiffList());//list-field-assign//sourceId:1035812_1
        }


        return retData;
    }

    /**
     * D2执行数据集去除空值数据(公共)[7262]
     * gen by moon at 6/27/2023, 1:41:47 PM
     */
    @Trace(operationName = "D2执行数据集去除空值数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataSetRemoveNullDataComRespDto implementDataSetRemoveNullDataCom(ImplementDataSetRemoveNullDataComReqDto reqDto) {


        ImplementDataSetRemoveNullDataRespDto dataSetRemoveNullDataRes_1 = null;
//步骤0: M2执行数据集去除空值数据（特殊方法） - implementDataSetRemoveNullData
        //ModelCode: dataSetRemoveNullData
        ImplementDataSetRemoveNullDataRespDto dataSetRemoveNullDataRes = null;
        ImplementDataSetRemoveNullDataReqDto dataSetRemoveNullDataReq = new ImplementDataSetRemoveNullDataReqDto();
        if (reqDto != null) {
            dataSetRemoveNullDataReq.setDataSetRemoveNullDataList(reqDto.getDataSetRemoveNullDataList().stream().map(item -> BeanUtil.toBean(item, DataSetRemoveNullDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1066449_1
        }

        /*M2执行数据集去除空值数据（特殊方法）[7261]  入参数据集，数据集主键A+非主键B,将B字段为空的数据记录过滤掉（不为空的出参） */

        dataSetRemoveNullDataRes = nbInterfaceMode.implementDataSetRemoveNullData(dataSetRemoveNullDataReq);


        dataSetRemoveNullDataRes_1 = dataSetRemoveNullDataRes;

        ImplementDataSetRemoveNullDataComRespDto retData = new ImplementDataSetRemoveNullDataComRespDto();
        //todo dong 未找到匹配生成策略,请检查生成策略retData.setDataSetRemoveNullDataList(dataSetRemoveNullDataRes_1.getDataSetRemoveNullDataList().getCommPrimaryKey()/dataSetRemoveNullDataRes_1.getDataSetRemoveNullDataList().getComFloatField()),数据源项; to( ==>tableName:undefined, fieldEnname:dataSetRemoveNullDataList ,uniqueId: 1066451_1 uniqueSourceId:out_null_null) from (varName:undefined fieldundefined)


        return retData;
    }

    /**
     * D2执行数据集随机一条记录(公共)[7270]
     * gen by moon at 6/28/2023, 1:28:47 AM
     */
    @Trace(operationName = "D2执行数据集随机一条记录(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataStochasticOneComRespDto implementDataStochasticOneCom(ImplementDataStochasticOneComReqDto reqDto) {


        ObtainDataStochasticOneRespDto dataStochasticOneRes_1 = null;
//步骤0: M2获取数据集随机一条记录（特殊方法） - obtainDataStochasticOne
        //ModelCode: dataStochasticOne
        ObtainDataStochasticOneRespDto dataStochasticOneRes = null;
        ObtainDataStochasticOneReqDto dataStochasticOneReq = new ObtainDataStochasticOneReqDto();
        if (reqDto != null) {
            dataStochasticOneReq.setDataStochasticOneList(reqDto.getDataStochasticOneList());//list-field-assign//sourceId:1070389_1
        }

        /*M2获取数据集随机一条记录（特殊方法）[7269]  入参数据集，随机出参数据集的单条记录 */

        dataStochasticOneRes = nbInterfaceMode.obtainDataStochasticOne(dataStochasticOneReq);


        dataStochasticOneRes_1 = dataStochasticOneRes;

        ImplementDataStochasticOneComRespDto retData = new ImplementDataStochasticOneComRespDto();
        if (dataStochasticOneRes_1 != null) {
            retData.setCustomField(dataStochasticOneRes_1.getCustomField());//SimpleFieldAssign//sourceId:1070392_1
        }


        return retData;
    }

    /**
     * D2查询接收出入参业务字段详情(公共)[7306]
     * gen by moon at 1/21/2024, 9:48:15 PM
     */
    @Trace(operationName = "D2查询接收出入参业务字段详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAcceptParameterBizFieldDetailComRespDto queryAcceptParameterBizFieldDetailCom(QueryAcceptParameterBizFieldDetailComReqDto reqDto) {


        ObtainReceiveFieldsRespDto receptionServiceRes_1 = null;
//步骤0: M2获取接收字段 - obtainReceiveFields
        //ModelCode: receptionService
        ObtainReceiveFieldsRespDto receptionServiceRes = null;
        ObtainReceiveFieldsReqDto receptionServiceReq = new ObtainReceiveFieldsReqDto();
        if (reqDto != null) {
            receptionServiceReq.setMemberChannelRelationId(reqDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1091537_1
        }

        /*M2获取接收字段[4007]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getMemberChannelRelationId(), "D2查询接收出入参业务字段详情(公共)-M2获取接收字段-成员通道关系ID不能为空", false);
        receptionServiceRes = nbInterfaceMode.obtainReceiveFields(receptionServiceReq);


        receptionServiceRes_1 = receptionServiceRes;

        QueryAcceptParameterBizFieldDetailComRespDto retData = new QueryAcceptParameterBizFieldDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setMemberChannelRelationId(receptionServiceRes_1.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1091540_1
        }


        return retData;
    }

    /**
     * D2执行多字段数据集记录去重(公共)[7323]
     * gen by moon at 8/1/2023, 9:39:15 PM
     */
    @Trace(operationName = "D2执行多字段数据集记录去重(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalCom(ImplementManyFieldsDataSetDuplicateRemovalComReqDto reqDto) {


        ImplementManyFieldsDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes_1 = null;
//步骤0: M2执行多字段数据集记录去重（特殊方法） - implementManyFieldsDataSetDuplicateRemoval
        //ModelCode: collectionRemoveDuplicateData
        ImplementManyFieldsDataSetDuplicateRemovalRespDto collectionRemoveDuplicateDataRes = null;
        ImplementManyFieldsDataSetDuplicateRemovalReqDto collectionRemoveDuplicateDataReq = new ImplementManyFieldsDataSetDuplicateRemovalReqDto();
        if (reqDto != null && reqDto.getDataSetDuplicateRemovalList() != null && !CollectionUtil.isEmpty(reqDto.getDataSetDuplicateRemovalList())) {
            collectionRemoveDuplicateDataReq.setDataSetDuplicateRemovalList(reqDto.getDataSetDuplicateRemovalList().stream().map(item -> BeanUtil.toBean(item, DataSetDuplicateRemovalDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1095616_1
        }

        /*M2执行多字段数据集记录去重（特殊方法）[7324]  入参一个数据集，通过去重标识，去除数据集中重复的数据 */

        collectionRemoveDuplicateDataRes = nbInterfaceMode.implementManyFieldsDataSetDuplicateRemoval(collectionRemoveDuplicateDataReq);


        collectionRemoveDuplicateDataRes_1 = collectionRemoveDuplicateDataRes;

        ImplementManyFieldsDataSetDuplicateRemovalComRespDto retData = new ImplementManyFieldsDataSetDuplicateRemovalComRespDto();
        if (collectionRemoveDuplicateDataRes_1 != null) {
            retData.setDataSetDuplicateRemovalList(collectionRemoveDuplicateDataRes_1.getDataSetDuplicateRemovalList().stream().map(item -> BeanUtil.toBean(item, DataSetDuplicateRemovalDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1095619_1
        }


        return retData;
    }

    /**
     * D2-执行时间加减固定数值(公共)[7369]
     * gen by moon at 11/29/2023, 3:21:16 AM
     */
    @Trace(operationName = "D2-执行时间加减固定数值(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTimeAddAndSubComRespDto implementTimeAddAndSubCom(ImplementTimeAddAndSubComReqDto reqDto) {


        ImplementTimeAddAndSubRespDto timeAddAndSubRes_1 = null;
//步骤0: M2-执行时间加减操作 - implementTimeAddAndSub
        //ModelCode: timeAddAndSub
        ImplementTimeAddAndSubRespDto timeAddAndSubRes = null;
        ImplementTimeAddAndSubReqDto timeAddAndSubReq = new ImplementTimeAddAndSubReqDto();
        if (reqDto != null) {
            timeAddAndSubReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:1111371_1
            timeAddAndSubReq.setCalcFormula(reqDto.getCalcFormula());//SimpleFieldAssign//sourceId:1111372_1
            timeAddAndSubReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1111370_1
            timeAddAndSubReq.setComNumField(reqDto.getComNumField());//SimpleFieldAssign//sourceId:1111373_1
        }

        /*M2-执行时间加减操作[7368]   */
        Assert.isNull(timeAddAndSubReq.getComTimeField(), "D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-通用时间字段不能为空", false);
        Assert.isNull(timeAddAndSubReq.getCalcFormula(), "D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-通用计算公式不能为空", false);
        Assert.isNull(timeAddAndSubReq.getTimeUnitType(), "D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-时间单位类型不能为空", false);
        Assert.isNull(timeAddAndSubReq.getComNumField(), "D2-执行时间加减固定数值(公共)-M2-执行时间加减操作-通用数值字段（整数型）不能为空", false);
        timeAddAndSubRes = nbInterfaceMode.implementTimeAddAndSub(timeAddAndSubReq);


        timeAddAndSubRes_1 = timeAddAndSubRes;

        ImplementTimeAddAndSubComRespDto retData = new ImplementTimeAddAndSubComRespDto();
        if (timeAddAndSubRes_1 != null) {
            retData.setCalcTimeResult(timeAddAndSubRes_1.getCalcTimeResult());//SimpleFieldAssign//sourceId:1111379_1
        }


        return retData;
    }

    /**
     * D2-执行多时间类型对比(公共)[7376]
     * gen by moon at 9/3/2023, 8:28:58 PM
     */
    @Trace(operationName = "D2-执行多时间类型对比(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementComparisonOfMultipleTimeTypesComRespDto implementComparisonOfMultipleTimeTypesCom(ImplementComparisonOfMultipleTimeTypesComReqDto reqDto) {


        ImplementComparisonOfMultipleTimeTypesRespDto comparisonOfMultipleTimeTypesRes_1 = null;
//步骤0: M2-执行多时间类型对比（特殊方法） - implementComparisonOfMultipleTimeTypes
        //ModelCode: comparisonOfMultipleTimeTypes
        ImplementComparisonOfMultipleTimeTypesRespDto comparisonOfMultipleTimeTypesRes = null;
        ImplementComparisonOfMultipleTimeTypesReqDto comparisonOfMultipleTimeTypesReq = new ImplementComparisonOfMultipleTimeTypesReqDto();
        if (reqDto != null) {
            comparisonOfMultipleTimeTypesReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1118319_1
            comparisonOfMultipleTimeTypesReq.setCompareTime(reqDto.getCompareTime());//SimpleFieldAssign//sourceId:1118320_1
            comparisonOfMultipleTimeTypesReq.setCaluStartTime(reqDto.getCaluStartTime());//SimpleFieldAssign//sourceId:1118321_1
        }

        /*M2-执行多时间类型对比（特殊方法）[7375]  按不同的时间类型（按年比较、按月比较、按天比较、按时间比较），结合入参开始时间（参照值）、结束时间（比较值）两个字段，计算比较值与参照值大小，输出两个时间比较结果之前（小于）、当前（等于）、之后（大于） */
        Assert.isNull(comparisonOfMultipleTimeTypesReq.getTimeUnitType(), "D2-执行多时间类型对比(公共)-M2-执行多时间类型对比（特殊方法）-时间单位类型不能为空", false);
        Assert.isNull(comparisonOfMultipleTimeTypesReq.getCompareTime(), "D2-执行多时间类型对比(公共)-M2-执行多时间类型对比（特殊方法）-比较时间不能为空", false);
        Assert.isNull(comparisonOfMultipleTimeTypesReq.getCaluStartTime(), "D2-执行多时间类型对比(公共)-M2-执行多时间类型对比（特殊方法）-参照时间不能为空", false);
        comparisonOfMultipleTimeTypesRes = nbInterfaceMode.implementComparisonOfMultipleTimeTypes(comparisonOfMultipleTimeTypesReq);


        comparisonOfMultipleTimeTypesRes_1 = comparisonOfMultipleTimeTypesRes;

        ImplementComparisonOfMultipleTimeTypesComRespDto retData = new ImplementComparisonOfMultipleTimeTypesComRespDto();
        if (comparisonOfMultipleTimeTypesRes_1 != null) {
            retData.setTimeCompareResult(comparisonOfMultipleTimeTypesRes_1.getTimeCompareResult());//SimpleFieldAssign//sourceId:1118326_1
        }


        return retData;
    }

    /**
     * D2获取数据集按入参过滤指定记录(公共)[7387]
     * gen by moon at 6/16/2024, 2:26:29 AM
     */
    @Trace(operationName = "D2获取数据集按入参过滤指定记录(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainDataFilterSpecRecByComRespDto obtainDataFilterSpecRecByCom(ObtainDataFilterSpecRecByComReqDto reqDto) {


        ObtainDataFilterSpecRecByRespDto dataFilterSpecRecByRes_1 = null;
//步骤0: M2获取数据集按入参过滤指定记录(特殊方法) - obtainDataFilterSpecRecBy
        //ModelCode: dataFilterSpecRecBy
        ObtainDataFilterSpecRecByRespDto dataFilterSpecRecByRes = null;
        ObtainDataFilterSpecRecByReqDto dataFilterSpecRecByReq = new ObtainDataFilterSpecRecByReqDto();
        if (reqDto != null && reqDto.getDataFilterSpecRecByList() != null && !CollectionUtil.isEmpty(reqDto.getDataFilterSpecRecByList())) {
            dataFilterSpecRecByReq.setDataFilterSpecRecByList(reqDto.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1120316_1
        }
        if (reqDto != null) {
            dataFilterSpecRecByReq.setComTxtField(reqDto.getComTxtField());//SimpleFieldAssign//sourceId:1120317_1
        }

    /*M2获取数据集按入参过滤指定记录(特殊方法)[7205]  目前用于购物车步骤判断。入参：步骤数据集+三个步骤字段（字段名与数据集中步骤编码相同）
处理逻辑：入参步骤字段值不为1，则将数据集中步骤编码同名的记录从出参数据集中删除 */
        Assert.isNull(dataFilterSpecRecByReq.getComTxtField(), "D2获取数据集按入参过滤指定记录(公共)-M2获取数据集按入参过滤指定记录(特殊方法)-通用文本字段不能为空", false);
        dataFilterSpecRecByRes = nbInterfaceMode.obtainDataFilterSpecRecBy(dataFilterSpecRecByReq);


        dataFilterSpecRecByRes_1 = dataFilterSpecRecByRes;

        ObtainDataFilterSpecRecByComRespDto retData = new ObtainDataFilterSpecRecByComRespDto();
        if (dataFilterSpecRecByRes_1 != null) {
            retData.setDataFilterSpecRecByList(dataFilterSpecRecByRes_1.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1120321_1
        }


        return retData;
    }

    /**
     * D2-执行富文本转markdown(公共)[7390]
     * gen by moon at 9/14/2023, 4:14:01 PM
     */
    @Trace(operationName = "D2-执行富文本转markdown(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementHypertextTurnToMarkdownComRespDto implementHypertextTurnToMarkdownCom(ImplementHypertextTurnToMarkdownComReqDto reqDto) {


        ImplementHypertextTurnToMarkdownRespDto hypertextTurnToMarkdownRes_1 = null;
//步骤0: M2-执行富文本转markdown（特殊方法） - implementHypertextTurnToMarkdown
        //ModelCode: hypertextTurnToMarkdown
        ImplementHypertextTurnToMarkdownRespDto hypertextTurnToMarkdownRes = null;
        ImplementHypertextTurnToMarkdownReqDto hypertextTurnToMarkdownReq = new ImplementHypertextTurnToMarkdownReqDto();
        if (reqDto != null) {
            hypertextTurnToMarkdownReq.setHypertextContent(reqDto.getHypertextContent());//SimpleFieldAssign//sourceId:1120446_1
        }

        /*M2-执行富文本转markdown（特殊方法）[7389]   */
        Assert.isNull(hypertextTurnToMarkdownReq.getHypertextContent(), "D2-执行富文本转markdown(公共)-M2-执行富文本转markdown（特殊方法）-超文本内容不能为空", false);
        hypertextTurnToMarkdownRes = nbInterfaceMode.implementHypertextTurnToMarkdown(hypertextTurnToMarkdownReq);


        hypertextTurnToMarkdownRes_1 = hypertextTurnToMarkdownRes;

        ImplementHypertextTurnToMarkdownComRespDto retData = new ImplementHypertextTurnToMarkdownComRespDto();
        if (hypertextTurnToMarkdownRes_1 != null) {
            retData.setMarkdownContent(hypertextTurnToMarkdownRes_1.getMarkdownContent());//SimpleFieldAssign//sourceId:1120449_1
        }


        return retData;
    }

    /**
     * D2执行对接第三方发送消息(公共)[7421]
     * gen by moon at 9/25/2023, 10:44:49 AM
     */
    @Trace(operationName = "D2执行对接第三方发送消息(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementObtainThirdSendMsgComRespDto implementObtainThirdSendMsgCom(ImplementObtainThirdSendMsgComReqDto reqDto) {


        //步骤0: M2-执行对接第三方发送消息（特殊方法） - implementObtainThirdSendMsg
        //ModelCode: obtainThirdSendMsg
        ImplementObtainThirdSendMsgRespDto obtainThirdSendMsgRes = null;
        ImplementObtainThirdSendMsgReqDto obtainThirdSendMsgReq = new ImplementObtainThirdSendMsgReqDto();
        if (reqDto != null) {
            obtainThirdSendMsgReq.setMessageServeUrl(reqDto.getMessageServeUrl());//SimpleFieldAssign//sourceId:1135340_1
            obtainThirdSendMsgReq.setMsgAppIdFields(reqDto.getMsgAppIdFields());//SimpleFieldAssign//sourceId:1123561_1
            obtainThirdSendMsgReq.setInterfaceMethod(reqDto.getInterfaceMethod());//SimpleFieldAssign//sourceId:1123573_1
            obtainThirdSendMsgReq.setMessageTitleFields(reqDto.getMessageTitleFields());//SimpleFieldAssign//sourceId:1123555_1
            obtainThirdSendMsgReq.setMessageContentFields(reqDto.getMessageContentFields());//SimpleFieldAssign//sourceId:1123556_1
            obtainThirdSendMsgReq.setMessageReceiverFields(reqDto.getMessageReceiverFields());//SimpleFieldAssign//sourceId:1123557_1
            obtainThirdSendMsgReq.setMsgAppId(reqDto.getMsgAppId());//SimpleFieldAssign//sourceId:1123562_1
            obtainThirdSendMsgReq.setMessageTitle(reqDto.getMessageTitle());//SimpleFieldAssign//sourceId:1123558_1
            obtainThirdSendMsgReq.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1123559_1
            obtainThirdSendMsgReq.setMessageReceiver(reqDto.getMessageReceiver());//SimpleFieldAssign//sourceId:1123560_1
        }

        /*M2-执行对接第三方发送消息（特殊方法）[7395]   */
        Assert.isNull(obtainThirdSendMsgReq.getMessageServeUrl(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息服务地址不能为空", false);
        Assert.isNull(obtainThirdSendMsgReq.getMsgAppIdFields(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息应用ID字段名不能为空", false);
        Assert.isNull(obtainThirdSendMsgReq.getInterfaceMethod(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-接口请求类型不能为空", false);
        Assert.isNull(obtainThirdSendMsgReq.getMessageTitleFields(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息标题字段名不能为空", false);
        Assert.isNull(obtainThirdSendMsgReq.getMessageContentFields(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息内容字段名不能为空", false);
        Assert.isNull(obtainThirdSendMsgReq.getMessageReceiverFields(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息接收方字段名不能为空", false);
        Assert.isNull(obtainThirdSendMsgReq.getMsgAppId(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息应用ID不能为空", false);
        Assert.isNull(obtainThirdSendMsgReq.getMessageReceiver(), "D2执行对接第三方发送消息(公共)-M2-执行对接第三方发送消息（特殊方法）-消息接收方不能为空", false);
        obtainThirdSendMsgRes = nbInterfaceMode.implementObtainThirdSendMsg(obtainThirdSendMsgReq);


        ImplementObtainThirdSendMsgComRespDto retData = new ImplementObtainThirdSendMsgComRespDto();


        return retData;
    }

    /**
     * D2-获取字符串长度(公共)[7491]
     * gen by moon at 10/4/2023, 10:16:38 PM
     */
    @Trace(operationName = "D2-获取字符串长度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementGetStringLengthComRespDto implementGetStringLengthCom(ImplementGetStringLengthComReqDto reqDto) {


        ImplementGetStringLengthRespDto stringLengthRes_1 = null;
//步骤0: M2-获取字符串长度（特殊方法） - implementGetStringLength
        //ModelCode: stringLength
        ImplementGetStringLengthRespDto stringLengthRes = null;
        ImplementGetStringLengthReqDto stringLengthReq = new ImplementGetStringLengthReqDto();
        if (reqDto != null) {
            stringLengthReq.setCustomText(reqDto.getCustomText());//SimpleFieldAssign//sourceId:1159234_1
        }

        /*M2-获取字符串长度（特殊方法）[7490]   */
        Assert.isNull(stringLengthReq.getCustomText(), "D2-获取字符串长度(公共)-M2-获取字符串长度（特殊方法）-自定义文本字段不能为空", false);
        stringLengthRes = nbInterfaceMode.implementGetStringLength(stringLengthReq);


        stringLengthRes_1 = stringLengthRes;

        ImplementGetStringLengthComRespDto retData = new ImplementGetStringLengthComRespDto();
        if (stringLengthRes_1 != null) {
            retData.setOutputNum(stringLengthRes_1.getOutputNum());//SimpleFieldAssign//sourceId:1159238_1
        }


        return retData;
    }

    /**
     * D2-执行数据集根据排序字段取最大最小(公共)[7500]
     * gen by moon at 10/5/2023, 3:54:43 PM
     */
    @Trace(operationName = "D2-执行数据集根据排序字段取最大最小(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataListGetMaxOrMiniByOrderNumberComRespDto implementDataListGetMaxOrMiniByOrderNumberCom(ImplementDataListGetMaxOrMiniByOrderNumberComReqDto reqDto) {


        ImplementDataListGetMaxOrMiniByOrderNumberRespDto dataListGetMaxOrMiniByOrderNumberRes_1 = null;
//步骤0: M2-执行数据集根据排序字段取最大最小（特殊方法） - implementDataListGetMaxOrMiniByOrderNumber
        //ModelCode: dataListGetMaxOrMiniByOrderNumber
        ImplementDataListGetMaxOrMiniByOrderNumberRespDto dataListGetMaxOrMiniByOrderNumberRes = null;
        ImplementDataListGetMaxOrMiniByOrderNumberReqDto dataListGetMaxOrMiniByOrderNumberReq = new ImplementDataListGetMaxOrMiniByOrderNumberReqDto();
        if (reqDto != null) {
            dataListGetMaxOrMiniByOrderNumberReq.setOrderSizeType(reqDto.getOrderSizeType());//SimpleFieldAssign//sourceId:1162306_1
            dataListGetMaxOrMiniByOrderNumberReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1162307_1
        }

        /*M2-执行数据集根据排序字段取最大最小（特殊方法）[7499]   */

        dataListGetMaxOrMiniByOrderNumberRes = nbInterfaceMode.implementDataListGetMaxOrMiniByOrderNumber(dataListGetMaxOrMiniByOrderNumberReq);


        dataListGetMaxOrMiniByOrderNumberRes_1 = dataListGetMaxOrMiniByOrderNumberRes;

        ImplementDataListGetMaxOrMiniByOrderNumberComRespDto retData = new ImplementDataListGetMaxOrMiniByOrderNumberComRespDto();
        if (dataListGetMaxOrMiniByOrderNumberRes_1 != null) {
            retData.setCustomField(dataListGetMaxOrMiniByOrderNumberRes_1.getCustomField());//SimpleFieldAssign//sourceId:1162311_1
            retData.setCustomField1(dataListGetMaxOrMiniByOrderNumberRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1162336_1
        }


        return retData;
    }

    /**
     * D2-执行两数相比输出指定文本(公共)[7513]
     * gen by moon at 12/2/2023, 12:08:53 AM
     */
    @Trace(operationName = "D2-执行两数相比输出指定文本(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCompTwoNumberOutputSpecTextComRespDto implementCompTwoNumberOutputSpecTextCom(ImplementCompTwoNumberOutputSpecTextComReqDto reqDto) {


        ImplementCompTwoNumberOutputSpecTextRespDto compTwoNumberOutputSpecTextRes_1 = null;
//步骤0: M2-执行两数相比输出指定文本（特殊方法） - implementCompTwoNumberOutputSpecText
        //ModelCode: compTwoNumberOutputSpecText
        ImplementCompTwoNumberOutputSpecTextRespDto compTwoNumberOutputSpecTextRes = null;
        ImplementCompTwoNumberOutputSpecTextReqDto compTwoNumberOutputSpecTextReq = new ImplementCompTwoNumberOutputSpecTextReqDto();
        if (reqDto != null) {
            compTwoNumberOutputSpecTextReq.setComFloatField(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:1362248_1
            compTwoNumberOutputSpecTextReq.setFixedValue(reqDto.getFixedValue());//SimpleFieldAssign//sourceId:1168241_1
            compTwoNumberOutputSpecTextReq.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1363795_1
        }

    /*M2-执行两数相比输出指定文本（特殊方法）[7512]  入参：A（数值），B（约定固定数值）
出参：C（文本）
业务描述：
目的是为了实现在显示任务超时时长时，如果超时时长小于100小时（系统配置），则显示超时时长；如果超时时长大于100小时，则显示100+，业务场景中显示文案为”当前汇报任务已逾期100+小时，请及时汇报“
逻辑描述：
两个数值A（10），B（100），如果A小于B，则输出A（10）
如果A大于B，则输出B（100+）
注意：输出的B是在入参100的基础上拼接了”+“符号 */
        Assert.isNull(compTwoNumberOutputSpecTextReq.getComFloatField(), "D2-执行两数相比输出指定文本(公共)-M2-执行两数相比输出指定文本（特殊方法）-通用数值字段（小数型）不能为空", false);
        Assert.isNull(compTwoNumberOutputSpecTextReq.getFixedValue(), "D2-执行两数相比输出指定文本(公共)-M2-执行两数相比输出指定文本（特殊方法）-固定数值不能为空", false);
        compTwoNumberOutputSpecTextRes = nbInterfaceMode.implementCompTwoNumberOutputSpecText(compTwoNumberOutputSpecTextReq);


        compTwoNumberOutputSpecTextRes_1 = compTwoNumberOutputSpecTextRes;

        ImplementCompTwoNumberOutputSpecTextComRespDto retData = new ImplementCompTwoNumberOutputSpecTextComRespDto();
        if (compTwoNumberOutputSpecTextRes_1 != null) {
            retData.setCustomField(compTwoNumberOutputSpecTextRes_1.getCustomField());//SimpleFieldAssign//sourceId:1168307_1
        }


        return retData;
    }

    /**
     * D2执行数据集按指定格式转文本(公共)[7515]
     * gen by moon at 12/12/2023, 7:18:54 PM
     */
    @Trace(operationName = "D2执行数据集按指定格式转文本(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataAppointFormatShiftTextComRespDto implementDataAppointFormatShiftTextCom(ImplementDataAppointFormatShiftTextComReqDto reqDto) {


        ImplementDataAppointFormatShiftTextRespDto dataAppointFormatShiftTextRes_1 = null;
//步骤0: M2执行数据集按指定格式转文本 - implementDataAppointFormatShiftText
        //ModelCode: dataAppointFormatShiftText
        ImplementDataAppointFormatShiftTextRespDto dataAppointFormatShiftTextRes = null;
        ImplementDataAppointFormatShiftTextReqDto dataAppointFormatShiftTextReq = new ImplementDataAppointFormatShiftTextReqDto();
        if (reqDto != null) {
            dataAppointFormatShiftTextReq.setDataAppointFormatShiftTextList(reqDto.getDataAppointFormatShiftTextList());//list-field-assign//sourceId:1168447_1
            dataAppointFormatShiftTextReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1168448_1
        }

        /*M2执行数据集按指定格式转文本[7419]   */

        dataAppointFormatShiftTextRes = nbInterfaceMode.implementDataAppointFormatShiftText(dataAppointFormatShiftTextReq);


        dataAppointFormatShiftTextRes_1 = dataAppointFormatShiftTextRes;

        ImplementDataAppointFormatShiftTextComRespDto retData = new ImplementDataAppointFormatShiftTextComRespDto();
        if (dataAppointFormatShiftTextRes_1 != null) {
            retData.setCustomText(dataAppointFormatShiftTextRes_1.getCustomText());//SimpleFieldAssign//sourceId:1168457_1
        }


        return retData;
    }

    /**
     * D2-执行markdown转文本(公共)[7517]
     * gen by moon at 10/9/2023, 8:42:56 PM
     */
    @Trace(operationName = "D2-执行markdown转文本(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextCom(ImplementMarkdownTurnToTextComReqDto reqDto) {


        ImplementMarkdownTurnToTextRespDto markdownTurnToTextRes_1 = null;
//步骤0: M2-执行markdown转文本（特殊方法） - implementMarkdownTurnToText
        //ModelCode: markdownTurnToText
        ImplementMarkdownTurnToTextRespDto markdownTurnToTextRes = null;
        ImplementMarkdownTurnToTextReqDto markdownTurnToTextReq = new ImplementMarkdownTurnToTextReqDto();
        if (reqDto != null) {
            markdownTurnToTextReq.setMarkdownContent(reqDto.getMarkdownContent());//SimpleFieldAssign//sourceId:1168553_1
        }

        /*M2-执行markdown转文本（特殊方法）[7516]   */

        markdownTurnToTextRes = nbInterfaceMode.implementMarkdownTurnToText(markdownTurnToTextReq);


        markdownTurnToTextRes_1 = markdownTurnToTextRes;

        ImplementMarkdownTurnToTextComRespDto retData = new ImplementMarkdownTurnToTextComRespDto();
        if (markdownTurnToTextRes_1 != null) {
            retData.setCustomText(markdownTurnToTextRes_1.getCustomText());//SimpleFieldAssign//sourceId:1168556_1
        }


        return retData;
    }

    /**
     * D2-执行markdown数据集转文本(公共)[7597]
     * gen by moon at 10/22/2023, 7:36:16 PM
     */
    @Trace(operationName = "D2-执行markdown数据集转文本(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMarkdownDataListTurnToTextComRespDto implementMarkdownDataListTurnToTextCom(ImplementMarkdownDataListTurnToTextComReqDto reqDto) {


        ImplementMarkdownDataListTurnToTextRespDto markdownDataListTurnToTextRes_1 = null;
//步骤0: M2-执行markdown数据集转文本 - implementMarkdownDataListTurnToText
        //ModelCode: markdownDataListTurnToText
        ImplementMarkdownDataListTurnToTextRespDto markdownDataListTurnToTextRes = null;
        ImplementMarkdownDataListTurnToTextReqDto markdownDataListTurnToTextReq = new ImplementMarkdownDataListTurnToTextReqDto();
        if (reqDto != null) {
            markdownDataListTurnToTextReq.setMarkdownDataListTurnToTextList(reqDto.getMarkdownDataListTurnToTextList().stream().map(item -> BeanUtil.toBean(item, MarkdownDataListTurnToTextDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1199573_1
        }

        /*M2-执行markdown数据集转文本[7596]   */

        markdownDataListTurnToTextRes = nbInterfaceMode.implementMarkdownDataListTurnToText(markdownDataListTurnToTextReq);


        markdownDataListTurnToTextRes_1 = markdownDataListTurnToTextRes;

        ImplementMarkdownDataListTurnToTextComRespDto retData = new ImplementMarkdownDataListTurnToTextComRespDto();
        if (markdownDataListTurnToTextRes_1 != null) {
            retData.setMarkdownDataListTurnToTextList(markdownDataListTurnToTextRes_1.getMarkdownDataListTurnToTextList().stream().map(item -> BeanUtil.toBean(item, MarkdownDataListTurnToTextDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1199576_1
        }


        return retData;
    }

    /**
     * D2-执行加密解密(公共)[7615]
     * gen by moon at 10/26/2023, 11:02:37 PM
     */
    @Trace(operationName = "D2-执行加密解密(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementEncryptionAndDecryptionComRespDto implementEncryptionAndDecryptionCom(ImplementEncryptionAndDecryptionComReqDto reqDto) {


        ImplementEncryptionAndDecryptionRespDto encryptionAndDecryptionRes_1 = null;
//步骤0: M2-执行加密解密（特殊方法） - implementEncryptionAndDecryption
        //ModelCode: encryptionAndDecryption
        ImplementEncryptionAndDecryptionRespDto encryptionAndDecryptionRes = null;
        ImplementEncryptionAndDecryptionReqDto encryptionAndDecryptionReq = new ImplementEncryptionAndDecryptionReqDto();
        if (reqDto != null) {
            encryptionAndDecryptionReq.setEncryptionOrDecryption(reqDto.getEncryptionOrDecryption());//SimpleFieldAssign//sourceId:1210191_1
            encryptionAndDecryptionReq.setEncryptionAndDecryptionMode(reqDto.getEncryptionAndDecryptionMode());//SimpleFieldAssign//sourceId:1210192_1
            encryptionAndDecryptionReq.setEncryptionAndDecryptionContent(reqDto.getEncryptionAndDecryptionContent());//SimpleFieldAssign//sourceId:1210193_1
        }

        /*M2-执行加密解密（特殊方法）[7614]   */
        Assert.isNull(encryptionAndDecryptionReq.getEncryptionOrDecryption(), "D2-执行加密解密(公共)-M2-执行加密解密（特殊方法）-加密解密类型不能为空", false);
        Assert.isNull(encryptionAndDecryptionReq.getEncryptionAndDecryptionMode(), "D2-执行加密解密(公共)-M2-执行加密解密（特殊方法）-加密解密方式不能为空", false);
        Assert.isNull(encryptionAndDecryptionReq.getEncryptionAndDecryptionContent(), "D2-执行加密解密(公共)-M2-执行加密解密（特殊方法）-加密解密文本不能为空", false);
        encryptionAndDecryptionRes = nbInterfaceMode.implementEncryptionAndDecryption(encryptionAndDecryptionReq);


        encryptionAndDecryptionRes_1 = encryptionAndDecryptionRes;

        ImplementEncryptionAndDecryptionComRespDto retData = new ImplementEncryptionAndDecryptionComRespDto();
        if (encryptionAndDecryptionRes_1 != null) {
            retData.setEncryptionAndDecryptionModeResult(encryptionAndDecryptionRes_1.getEncryptionAndDecryptionModeResult());//SimpleFieldAssign//sourceId:1210198_1
        }


        return retData;
    }

    /**
     * D2-执行固定密钥加密解密(公共)[7615]
     * gen by moon at 11/1/2023, 6:09:18 PM
     */
    @Trace(operationName = "D2-执行固定密钥加密解密(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementEncryptionAndDecryptionByFixedKeyComRespDto implementEncryptionAndDecryptionByFixedKeyCom(ImplementEncryptionAndDecryptionByFixedKeyComReqDto reqDto) {


        ImplementEncryptionAndDecryptionByFixedKeyRespDto encryptionAndDecryptionByFixedKeyRes_1 = null;
//步骤0: M2-执行固定密钥加密解密（特殊方法） - implementEncryptionAndDecryptionByFixedKey
        //ModelCode: encryptionAndDecryptionByFixedKey
        ImplementEncryptionAndDecryptionByFixedKeyRespDto encryptionAndDecryptionByFixedKeyRes = null;
        ImplementEncryptionAndDecryptionByFixedKeyReqDto encryptionAndDecryptionByFixedKeyReq = new ImplementEncryptionAndDecryptionByFixedKeyReqDto();
        if (reqDto != null) {
            encryptionAndDecryptionByFixedKeyReq.setEncryptionOrDecryption(reqDto.getEncryptionOrDecryption());//SimpleFieldAssign//sourceId:1210191_1
            encryptionAndDecryptionByFixedKeyReq.setEncryptionAndDecryptionMode(reqDto.getEncryptionAndDecryptionMode());//SimpleFieldAssign//sourceId:1210192_1
            encryptionAndDecryptionByFixedKeyReq.setEncryptionAndDecryptionContent(reqDto.getEncryptionAndDecryptionContent());//SimpleFieldAssign//sourceId:1210193_1
        }

        /*M2-执行固定密钥加密解密（特殊方法）[7614]   */
        Assert.isNull(encryptionAndDecryptionByFixedKeyReq.getEncryptionOrDecryption(), "D2-执行固定密钥加密解密(公共)-M2-执行固定密钥加密解密（特殊方法）-加密解密类型不能为空", false);
        Assert.isNull(encryptionAndDecryptionByFixedKeyReq.getEncryptionAndDecryptionMode(), "D2-执行固定密钥加密解密(公共)-M2-执行固定密钥加密解密（特殊方法）-加密解密方式不能为空", false);
        Assert.isNull(encryptionAndDecryptionByFixedKeyReq.getEncryptionAndDecryptionContent(), "D2-执行固定密钥加密解密(公共)-M2-执行固定密钥加密解密（特殊方法）-加密解密文本不能为空", false);
        encryptionAndDecryptionByFixedKeyRes = nbInterfaceMode.implementEncryptionAndDecryptionByFixedKey(encryptionAndDecryptionByFixedKeyReq);


        encryptionAndDecryptionByFixedKeyRes_1 = encryptionAndDecryptionByFixedKeyRes;

        ImplementEncryptionAndDecryptionByFixedKeyComRespDto retData = new ImplementEncryptionAndDecryptionByFixedKeyComRespDto();
        if (encryptionAndDecryptionByFixedKeyRes_1 != null) {
            retData.setEncryptionAndDecryptionModeResult(encryptionAndDecryptionByFixedKeyRes_1.getEncryptionAndDecryptionModeResult());//SimpleFieldAssign//sourceId:1210198_1
        }


        return retData;
    }

    /**
     * D2-执行动态密钥加密解密(公共)[7619]
     * gen by moon at 10/28/2023, 1:22:40 AM
     */
    @Trace(operationName = "D2-执行动态密钥加密解密(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementEncryptionAndDecryptionByDynamicKeyComRespDto implementEncryptionAndDecryptionByDynamicKeyCom(ImplementEncryptionAndDecryptionByDynamicKeyComReqDto reqDto) {


        ImplementEncryptionAndDecryptionByDynamicKeyRespDto encryptionAndDecryptionByDynamicKeyRes_1 = null;
//步骤0: M2-执行动态密钥加密解密（特殊方法） - implementEncryptionAndDecryptionByDynamicKey
        //ModelCode: encryptionAndDecryptionByDynamicKey
        ImplementEncryptionAndDecryptionByDynamicKeyRespDto encryptionAndDecryptionByDynamicKeyRes = null;
        ImplementEncryptionAndDecryptionByDynamicKeyReqDto encryptionAndDecryptionByDynamicKeyReq = new ImplementEncryptionAndDecryptionByDynamicKeyReqDto();
        if (reqDto != null) {
            encryptionAndDecryptionByDynamicKeyReq.setEncryptionOrDecryption(reqDto.getEncryptionOrDecryption());//SimpleFieldAssign//sourceId:1212264_1
            encryptionAndDecryptionByDynamicKeyReq.setEncryptionAndDecryptionMode(reqDto.getEncryptionAndDecryptionMode());//SimpleFieldAssign//sourceId:1212265_1
            encryptionAndDecryptionByDynamicKeyReq.setSecretKey(reqDto.getSecretKey());//SimpleFieldAssign//sourceId:1212266_
            encryptionAndDecryptionByDynamicKeyReq.setInitVector(reqDto.getInitVector());//SimpleFieldAssign//sourceId:1212401_1
            encryptionAndDecryptionByDynamicKeyReq.setEncryptionAndDecryptionContent(reqDto.getEncryptionAndDecryptionContent());//SimpleFieldAssign//sourceId:1212267_1
        }

        /*M2-执行动态密钥加密解密（特殊方法）[7618]   */
        Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getEncryptionOrDecryption(), "D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-加密解密类型不能为空", false);
        Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getEncryptionAndDecryptionMode(), "D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-加密解密方式不能为空", false);
        Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getSecretKey(), "D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-动态密钥不能为空", false);
        Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getInitVector(), "D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-初始化向量不能为空", false);
        Assert.isNull(encryptionAndDecryptionByDynamicKeyReq.getEncryptionAndDecryptionContent(), "D2-执行动态密钥加密解密(公共)-M2-执行动态密钥加密解密（特殊方法）-加密解密文本不能为空", false);
        encryptionAndDecryptionByDynamicKeyRes = nbInterfaceMode.implementEncryptionAndDecryptionByDynamicKey(encryptionAndDecryptionByDynamicKeyReq);


        encryptionAndDecryptionByDynamicKeyRes_1 = encryptionAndDecryptionByDynamicKeyRes;

        ImplementEncryptionAndDecryptionByDynamicKeyComRespDto retData = new ImplementEncryptionAndDecryptionByDynamicKeyComRespDto();
        if (encryptionAndDecryptionByDynamicKeyRes_1 != null) {
            retData.setEncryptionAndDecryptionModeResult(encryptionAndDecryptionByDynamicKeyRes_1.getEncryptionAndDecryptionModeResult());//SimpleFieldAssign//sourceId:1212273_1
        }


        return retData;
    }

    /**
     * D2-执行两时间之间加减(公共)[8036]
     * gen by moon at 11/29/2023, 4:54:40 PM
     */
    @Trace(operationName = "D2-执行两时间之间加减(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTwoTimeAddAndSubComRespDto implementTwoTimeAddAndSubCom(ImplementTwoTimeAddAndSubComReqDto reqDto) {


        ImplementTwoTimeAddAndSubRespDto twoTimeAddAndSubRes_1 = null;
        //步骤0: M2-执行两时间加减（特殊方法） - implementTwoTimeAddAndSub
        //ModelCode: twoTimeAddAndSub
        ImplementTwoTimeAddAndSubRespDto twoTimeAddAndSubRes = null;
        ImplementTwoTimeAddAndSubReqDto twoTimeAddAndSubReq = new ImplementTwoTimeAddAndSubReqDto();
        if (reqDto != null) {
            twoTimeAddAndSubReq.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1360031_1
            twoTimeAddAndSubReq.setCalcEndTime(reqDto.getCalcEndTime());//SimpleFieldAssign//sourceId:1360032_1
            twoTimeAddAndSubReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1360033_1
            twoTimeAddAndSubReq.setCalcFormula(reqDto.getCalcFormula());//SimpleFieldAssign//sourceId:1360034_1
            twoTimeAddAndSubReq.setDeviationDurationCompRule(reqDto.getDeviationDurationCompRule());//SimpleFieldAssign//sourceId:1360054_1
            twoTimeAddAndSubReq.setDecimalPointRules(reqDto.getDecimalPointRules());
            twoTimeAddAndSubReq.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());
        }

        /*M2-执行两时间加减（特殊方法）[8035]  入参：计算开始时间，计算结束时间，时间单位（月、天、时、分、秒。。），计算类型（加或减）。 用计算开始时间加或减计算结束时间，计算输入结果时间，计算出两个时间点之前的时间单位（如xx天，xx小时，xx分钟） */

        twoTimeAddAndSubRes = nbInterfaceMode.implementTwoTimeAddAndSub(twoTimeAddAndSubReq);


        twoTimeAddAndSubRes_1 = twoTimeAddAndSubRes;

        ImplementTwoTimeAddAndSubComRespDto retData = new ImplementTwoTimeAddAndSubComRespDto();
        if (twoTimeAddAndSubRes_1 != null) {
            retData.setTimeCalcResult(twoTimeAddAndSubRes_1.getTimeCalcResult());//SimpleFieldAssign//sourceId:1360058_1
        }


        return retData;
    }

    /**
     * D2-计算两个数值相加(公共)[8137]
     * gen by moon at 12/12/2023, 5:00:36 AM
     */
    @Trace(operationName = "D2-计算两个数值相加(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsCom(CalculateAdditionOfTwoNumsComReqDto reqDto) {


        CalculateAdditionOfTwoNumsRespDto additionOfTwoNumRes_1 = null;
//步骤0: M2计算两个数值相加（特殊方法） - calculateAdditionOfTwoNums
        //ModelCode: additionOfTwoNum
        CalculateAdditionOfTwoNumsRespDto additionOfTwoNumRes = null;
        CalculateAdditionOfTwoNumsReqDto additionOfTwoNumReq = new CalculateAdditionOfTwoNumsReqDto();
        if (reqDto != null) {
            additionOfTwoNumReq.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:1410384_1
            additionOfTwoNumReq.setCalcPara2(reqDto.getCalcPara2());//SimpleFieldAssign//sourceId:1410385_1
        }

        /*M2计算两个数值相加（特殊方法）[6472]  用户指标数据计算，入参两个数值，计算两数之和 */
        Assert.isNull(additionOfTwoNumReq.getCalcPara1(), "D2-计算两个数值相加(公共)-M2计算两个数值相加（特殊方法）-计算入参1不能为空", false);
        Assert.isNull(additionOfTwoNumReq.getCalcPara2(), "D2-计算两个数值相加(公共)-M2计算两个数值相加（特殊方法）-计算入参2不能为空", false);
        additionOfTwoNumRes = nbInterfaceMode.calculateAdditionOfTwoNums(additionOfTwoNumReq);


        additionOfTwoNumRes_1 = additionOfTwoNumRes;

        CalculateAdditionOfTwoNumsComRespDto retData = new CalculateAdditionOfTwoNumsComRespDto();
        if (additionOfTwoNumRes_1 != null) {
            retData.setCalcResult(additionOfTwoNumRes_1.getCalcResult());//SimpleFieldAssign//sourceId:1410389_1
        }


        return retData;
    }

    /**
     * D2判断数据集按入参去N条(公共)[8146]
     * gen by moon at 12/14/2023, 2:50:57 PM
     */
    @Trace(operationName = "D2判断数据集按入参去N条(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeDataPressRemoveMultipleEntriesComRespDto judgeDataPressRemoveMultipleEntriesCom(JudgeDataPressRemoveMultipleEntriesComReqDto reqDto) {


        JudgeDataPressRemoveMultipleEntriesRespDto dataPressRemoveMultipleEntriesRes_1 = null;
//步骤0: M2判断数据集按入参去N条 - judgeDataPressRemoveMultipleEntries
        //ModelCode: dataPressRemoveMultipleEntries
        JudgeDataPressRemoveMultipleEntriesRespDto dataPressRemoveMultipleEntriesRes = null;
        JudgeDataPressRemoveMultipleEntriesReqDto dataPressRemoveMultipleEntriesReq = new JudgeDataPressRemoveMultipleEntriesReqDto();
        if (reqDto != null) {
            dataPressRemoveMultipleEntriesReq.setDataFilterSpecRecByList(reqDto.getDataPressRemoveMultipleEntriesList().stream().map(item -> BeanUtil.toBean(item, DataFilterSpecRecByDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414819_1
            dataPressRemoveMultipleEntriesReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1414822_1
        }

        /*M2判断数据集按入参去N条[8147]   */
        Assert.isNull(dataPressRemoveMultipleEntriesReq.getCustomField(), "D2判断数据集按入参去N条(公共)-M2判断数据集按入参去N条-自定义字段不能为空", false);
        dataPressRemoveMultipleEntriesRes = nbInterfaceMode.judgeDataPressRemoveMultipleEntries(dataPressRemoveMultipleEntriesReq);


        dataPressRemoveMultipleEntriesRes_1 = dataPressRemoveMultipleEntriesRes;

        JudgeDataPressRemoveMultipleEntriesComRespDto retData = new JudgeDataPressRemoveMultipleEntriesComRespDto();
        if (dataPressRemoveMultipleEntriesRes_1 != null) {
            retData.setDataPressRemoveMultipleEntriesList(dataPressRemoveMultipleEntriesRes_1.getDataFilterSpecRecByList().stream().map(item -> BeanUtil.toBean(item, DataPressRemoveMultipleEntriesDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414826_1
        }


        return retData;
    }

    /**
     * D2执行接文本字段数据集(公共)[8148]
     * gen by moon at 12/16/2023, 11:14:47 PM
     */
    @Trace(operationName = "D2执行接文本字段数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementConnectTextFieldDatasetComRespDto implementConnectTextFieldDatasetCom(ImplementConnectTextFieldDatasetComReqDto reqDto) {


        ImplementConnectTextFieldDatasetRespDto receptionServiceRes_1 = null;
//步骤0: M2执行接文本字段数据集 - implementConnectTextFieldDataset
        //ModelCode: receptionService
        ImplementConnectTextFieldDatasetRespDto receptionServiceRes = null;
        ImplementConnectTextFieldDatasetReqDto receptionServiceReq = new ImplementConnectTextFieldDatasetReqDto();
        if (reqDto != null && reqDto.getConnectTextFieldDatasetList() != null && !CollectionUtil.isEmpty(reqDto.getConnectTextFieldDatasetList())) {
            receptionServiceReq.setConnectTextFieldDatasetList(reqDto.getConnectTextFieldDatasetList().stream().map(item -> BeanUtil.toBean(item, ConnectTextFieldDatasetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414833_1
        }

        /*M2执行接文本字段数据集[8149]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbInterfaceMode.implementConnectTextFieldDataset(receptionServiceReq);


        receptionServiceRes_1 = receptionServiceRes;

        ImplementConnectTextFieldDatasetComRespDto retData = new ImplementConnectTextFieldDatasetComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setConnectTextFieldDatasetList(receptionServiceRes_1.getConnectTextFieldDatasetList().stream().map(item -> BeanUtil.toBean(item, ConnectTextFieldDatasetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1414845_1
        }


        return retData;
    }

    /**
     * D2执行字段名与值转数据集(公共)[8173]
     * gen by moon at 12/21/2023, 12:35:06 AM
     */
    @Trace(operationName = "D2执行字段名与值转数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFieldsNameAndValueToOneDatasComRespDto implementFieldsNameAndValueToOneDatasCom(ImplementFieldsNameAndValueToOneDatasComReqDto reqDto) {


        ImplementFieldsNameAndValueToOneDatasRespDto fieldsNameAndValueToOneDatasRes_1 = null;
//步骤0: M2执行字段名与值转数据集 - implementFieldsNameAndValueToOneDatas
        //ModelCode: fieldsNameAndValueToOneDatas
        ImplementFieldsNameAndValueToOneDatasRespDto fieldsNameAndValueToOneDatasRes = null;
        ImplementFieldsNameAndValueToOneDatasReqDto fieldsNameAndValueToOneDatasReq = new ImplementFieldsNameAndValueToOneDatasReqDto();
        if (reqDto != null) {
            fieldsNameAndValueToOneDatasReq.setFieldName(reqDto.getFieldName());//SimpleFieldAssign//sourceId:1429706_1
            fieldsNameAndValueToOneDatasReq.setFieldValue(reqDto.getFieldValue());//SimpleFieldAssign//sourceId:1429707_1
        }

        /*M2执行字段名与值转数据集[8172]  用于将一个字段的字段名与字段值转成数据集 */

        fieldsNameAndValueToOneDatasRes = nbInterfaceMode.implementFieldsNameAndValueToOneDatas(fieldsNameAndValueToOneDatasReq);


        fieldsNameAndValueToOneDatasRes_1 = fieldsNameAndValueToOneDatasRes;

        ImplementFieldsNameAndValueToOneDatasComRespDto retData = new ImplementFieldsNameAndValueToOneDatasComRespDto();
        if (fieldsNameAndValueToOneDatasRes_1 != null) {
            retData.setFieldsNameAndValueToOneDatasList(fieldsNameAndValueToOneDatasRes_1.getFieldsNameAndValueToOneDatasList().stream().map(item -> BeanUtil.toBean(item, FieldsNameAndValueToOneDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1430386_1
        }


        return retData;
    }

    /**
     * D2执行时间格式化(公共)[8203]
     * gen by moon at 12/23/2023, 11:08:46 PM
     */
    @Trace(operationName = "D2执行时间格式化(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDateFormatComRespDto implementDateFormatCom(ImplementDateFormatComReqDto reqDto) {


        ImplementDateFormatRespDto dateFormatRes_1 = null;
//步骤0: M2执行时间格式化 - implementDateFormat
        //ModelCode: dateFormat
        ImplementDateFormatRespDto dateFormatRes = null;
        ImplementDateFormatReqDto dateFormatReq = new ImplementDateFormatReqDto();
        if (reqDto != null) {
            dateFormatReq.setComTimeField(reqDto.getComTimeField());//SimpleFieldAssign//sourceId:1441530_1
            dateFormatReq.setTimeFormatMode(reqDto.getTimeFormatMode());//SimpleFieldAssign//sourceId:1441531_1
        }

    /*M2执行时间格式化[8204]  yyyy-MM-dd: ISO 标准日期格式，例如 2023-12-23。
dd/MM/yyyy: 欧洲/亚洲日期格式，例如 23/12/2023。
MM/dd/yyyy: 美国日期格式，例如 12/23/2023。
yyyy-MM-dd HH:mm:ss: 完整的日期和时间，24小时制，例如 2023-12-23 15:45:30。
dd-MMM-yyyy: 文本月份，例如 23-Dec-2023。
E, MMM dd yyyy: 星期几和日期，例如 Sat, Dec 23 2023。
hh:mm:ss a: 12小时制的时间，带上午/下午标记，例如 03:45:30 PM。
HH:mm:ss: 24小时制的时间，例如 15:45:30。
yyyy-MM-dd'T'HH:mm:ss'Z': ISO 8601 UTC 时间格式，例如 2023-12-23T15:45:30Z。
yyyy-MM-dd HH:mm:ss.SSS: 带毫秒的时间，例如 2023-12-23 15:45:30.123 */
        Assert.isNull(dateFormatReq.getComTimeField(), "D2执行时间格式化(公共)-M2执行时间格式化-通用时间字段不能为空", false);
        Assert.isNull(dateFormatReq.getTimeFormatMode(), "D2执行时间格式化(公共)-M2执行时间格式化-时间格式模式不能为空", false);
        dateFormatRes = nbInterfaceMode.implementDateFormat(dateFormatReq);


        dateFormatRes_1 = dateFormatRes;

        ImplementDateFormatComRespDto retData = new ImplementDateFormatComRespDto();
        if (dateFormatRes_1 != null) {
            retData.setComTxtField(dateFormatRes_1.getComTxtField());//SimpleFieldAssign//sourceId:1441535_1
        }


        return retData;
    }

    /**
     * D2执行事务等待时长(公共)[8322]
     * gen by moon at 1/22/2024, 11:05:35 PM
     */
    @Trace(operationName = "D2执行事务等待时长(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTransactionWaitingTimeComRespDto implementTransactionWaitingTimeCom(ImplementTransactionWaitingTimeComReqDto reqDto) {


        //步骤0: M2执行事务等待时长(特殊方法） - implementTransactionWaitingTime
        //ModelCode: transactionWaitingTime
        ImplementTransactionWaitingTimeRespDto transactionWaitingTimeRes = null;
        ImplementTransactionWaitingTimeReqDto transactionWaitingTimeReq = new ImplementTransactionWaitingTimeReqDto();
        if (reqDto != null) {
            transactionWaitingTimeReq.setWaitingTime(reqDto.getWaitingTime());//SimpleFieldAssign//sourceId:1494570_1
        }

        /*M2执行事务等待时长(特殊方法）[8323]  在一个事务中，插入等待时长后，后续事务需要等待约定的时长后，再继续执行。 */
        Assert.isNull(transactionWaitingTimeReq.getWaitingTime(), "D2执行事务等待时长(公共)-M2执行事务等待时长(特殊方法）-等待时长不能为空", false);
        transactionWaitingTimeRes = nbInterfaceMode.implementTransactionWaitingTime(transactionWaitingTimeReq);


        ImplementTransactionWaitingTimeComRespDto retData = new ImplementTransactionWaitingTimeComRespDto();


        return retData;
    }

    /**
     * D2-执行并发行为主题锁(公共)[8388]
     * gen by moon at 6/2/2024, 10:24:10 PM
     */
    @Trace(operationName = "D2-执行并发行为主题锁(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComCom(ImplementConcBhvThemeLockComComReqDto reqDto) {


        ImplementConcBhvThemeLockComRespDto distributedLockingRes_1 = null;
        if ((reqDto != null && reqDto.getPreventConcurrentLockingUnlocking() != null && reqDto.getPreventConcurrentLockingUnlocking().equals("LOCK"))) {
            //if(D2-执行并发行为主题锁(公共).防并发上锁or解锁 等于 上锁)  60482

//ModelCode: distributedLocking
            ImplementConcBhvThemeLockComRespDto distributedLockingRes = null;
            ImplementConcBhvThemeLockComReqDto distributedLockingReq = new ImplementConcBhvThemeLockComReqDto();
            if (reqDto != null) {
                distributedLockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819322_1_60484
                distributedLockingReq.setBehaviorThemeLockCode(reqDto.getBehaviorThemeLockCode());//SimpleFieldAssign//sourceId:1517372_1_60484
                distributedLockingReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1517371_1_60484
                distributedLockingReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1517368_1_60484
                distributedLockingReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1517369_1_60484
                distributedLockingReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1517370_1_60484
                distributedLockingReq.setDuration(reqDto.getDuration());//SimpleFieldAssign//sourceId:1517373_1_60484
                distributedLockingReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1517374_1_60484
            }

            /*M2-执行并发行为主题锁（特殊方法）[8389]   */
            Assert.isNull(distributedLockingReq.getBehaviorThemeLockCode(), "D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空", false);
            Assert.isNull(distributedLockingReq.getCommPrimaryKey(), "D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-通用主键ID不能为空", false);
            Assert.isNull(distributedLockingReq.getDuration(), "D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-锁定时长不能为空", false);
            Assert.isNull(distributedLockingReq.getTimeUnitType(), "D2-执行并发行为主题锁(公共)-M2-执行并发行为主题锁（特殊方法）-时间单位类型不能为空", false);
            distributedLockingRes = nbInterfaceMode.implementConcBhvThemeLockCom(distributedLockingReq);


            distributedLockingRes_1 = distributedLockingRes;
            if ((reqDto != null && reqDto.getHandlingMethodConcurrentLockFailure() != null && reqDto.getHandlingMethodConcurrentLockFailure().equals("CONCURRENT_LOCK_FAILURE_ERROR_REPORTING") && distributedLockingRes != null && distributedLockingRes.getPreventConcurrentLockingSituations() != null && distributedLockingRes.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
                //if((D2-执行并发行为主题锁(公共).并发上锁失败处理方式 等于 并发上锁失败报错 and M2-执行并发行为主题锁（特殊方法）.防并发上锁情况 等于 并发上锁失败))  60486

//异常结束 60487
                throw new BizException("C00281", "对不起，当前操作繁忙，稍后再来～。", false);
            }
        } else if ((reqDto != null && reqDto.getPreventConcurrentLockingUnlocking() != null && reqDto.getPreventConcurrentLockingUnlocking().equals("UNLOCK"))) {
            //elseif(D2-执行并发行为主题锁(公共).防并发上锁or解锁 等于 解锁)  60483

            if ((reqDto != null && reqDto.getWhetherUnlockBulk() != null && reqDto.getWhetherUnlockBulk().equals("TRUE"))) {
                //if(D2-执行并发行为主题锁(公共).是否批量解锁 等于 是)  60489

//ModelCode: distributedBatchUnlock
                ImplementBatchUnlockingConcBhvThemesLockComRespDto distributedBatchUnlockRes = null;
                ImplementBatchUnlockingConcBhvThemesLockComReqDto distributedBatchUnlockReq = new ImplementBatchUnlockingConcBhvThemesLockComReqDto();
                if (reqDto != null) {
                    distributedBatchUnlockReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819324_1_60492
                    distributedBatchUnlockReq.setBehaviorThemeLockCode(reqDto.getBehaviorThemeLockCode());//SimpleFieldAssign//sourceId:1517392_1_60492
                    distributedBatchUnlockReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1517393_1_60492
                    distributedBatchUnlockReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1517394_1_60492
                    distributedBatchUnlockReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1517395_1_60492
                }

                /*M2-执行批量解锁并发行为主题锁（特殊方法）[8394]  批量解分布式锁 */
                Assert.isNull(distributedBatchUnlockReq.getBehaviorThemeLockCode(), "D2-执行并发行为主题锁(公共)-M2-执行批量解锁并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空", false);
                distributedBatchUnlockRes = nbInterfaceMode.implementBatchUnlockingConcBhvThemesLockCom(distributedBatchUnlockReq);


            } else if ((reqDto != null && reqDto.getWhetherUnlockBulk() != null && reqDto.getWhetherUnlockBulk().equals("FALSE"))) {
                //elseif(D2-执行并发行为主题锁(公共).是否批量解锁 等于 否)  60490

//ModelCode: distributedUnlocking
                ImplementUnlockingConcBhvThemesLockComRespDto distributedUnlockingRes = null;
                ImplementUnlockingConcBhvThemesLockComReqDto distributedUnlockingReq = new ImplementUnlockingConcBhvThemesLockComReqDto();
                if (reqDto != null) {
                    distributedUnlockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819326_1_60491
                    distributedUnlockingReq.setBehaviorThemeLockCode(reqDto.getBehaviorThemeLockCode());//SimpleFieldAssign//sourceId:1517401_1_60491
                    distributedUnlockingReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1517402_1_60491
                    distributedUnlockingReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1517403_1_60491
                    distributedUnlockingReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1517404_1_60491
                    distributedUnlockingReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1517405_1_60491
                }

                /*M2-执行解锁并发行为主题锁（特殊方法）[8393]   */
                Assert.isNull(distributedUnlockingReq.getBehaviorThemeLockCode(), "D2-执行并发行为主题锁(公共)-M2-执行解锁并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空", false);
                Assert.isNull(distributedUnlockingReq.getCommPrimaryKey(), "D2-执行并发行为主题锁(公共)-M2-执行解锁并发行为主题锁（特殊方法）-通用主键ID不能为空", false);
                distributedUnlockingRes = nbInterfaceMode.implementUnlockingConcBhvThemesLockCom(distributedUnlockingReq);


            }
        }
        ImplementConcBhvThemeLockComComRespDto retData = new ImplementConcBhvThemeLockComComRespDto();
        if (distributedLockingRes_1 != null) {
            retData.setPreventConcurrentLockingSituations(distributedLockingRes_1.getPreventConcurrentLockingSituations());//SimpleFieldAssign//sourceId:1521505_1
        }


        return retData;
    }

    /**
     * D2-新增redis业务数据对象(公共)[8395]
     * gen by moon at 5/31/2024, 8:33:34 PM
     */
    @Trace(operationName = "D2-新增redis业务数据对象(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddRedisBusinessDataComRespDto addRedisBusinessDataCom(AddRedisBusinessDataComReqDto reqDto) {


        //步骤0: M2-新增redis业务数据对象（特殊方法） - addRedisBusinessData
        //ModelCode: addRedisBusinessData
        AddRedisBusinessDataRespDto addRedisBusinessDataRes = null;
        AddRedisBusinessDataReqDto addRedisBusinessDataReq = new AddRedisBusinessDataReqDto();
        if (reqDto != null) {
            addRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517451_1
            addRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517506_1
            addRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819361_1
            addRedisBusinessDataReq.setIsDeleteRedis(reqDto.getIsDeleteRedis());//SimpleFieldAssign//sourceId:1782388_1
            addRedisBusinessDataReq.setDuration(reqDto.getDuration());//SimpleFieldAssign//sourceId:1819362_1
            addRedisBusinessDataReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1819363_1
            addRedisBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1517450_1
        }
        if (reqDto != null && reqDto.getFieldDataList() != null && !CollectionUtil.isEmpty(reqDto.getFieldDataList())) {
            addRedisBusinessDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517449_1
        }

        /*M2-新增redis业务数据对象（特殊方法）[8390]   */
        Assert.isNull(addRedisBusinessDataReq.getBusinessDataObject(), "D2-新增redis业务数据对象(公共)-M2-新增redis业务数据对象（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(addRedisBusinessDataReq.getRedisDataObjectCatalogue(), "D2-新增redis业务数据对象(公共)-M2-新增redis业务数据对象（特殊方法）-Redis数据对象目录不能为空", false);
        Assert.isNull(addRedisBusinessDataReq.getIsDataList(), "D2-新增redis业务数据对象(公共)-M2-新增redis业务数据对象（特殊方法）-是否是数据集对象不能为空", false);
        addRedisBusinessDataRes = nbInterfaceMode.addRedisBusinessData(addRedisBusinessDataReq);


        AddRedisBusinessDataComRespDto retData = new AddRedisBusinessDataComRespDto();


        return retData;
    }

    /**
     * D2-查询redis业务数据对象列表(公共)[8396]
     * gen by moon at 5/31/2024, 8:33:43 PM
     */
    @Trace(operationName = "D2-查询redis业务数据对象列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRedisBusinessDataListComRespDto queryRedisBusinessDataListCom(QueryRedisBusinessDataListComReqDto reqDto) {


        QueryRedisBusinessDataListRespDto queryRedisBusinessDataRes_1 = null;
//步骤0: M2-查询redis业务数据对象列表（特殊方法） - queryRedisBusinessDataList
        //ModelCode: queryRedisBusinessData
        QueryRedisBusinessDataListRespDto queryRedisBusinessDataRes = null;
        QueryRedisBusinessDataListReqDto queryRedisBusinessDataReq = new QueryRedisBusinessDataListReqDto();
        if (reqDto != null) {
            queryRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517516_1
            queryRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517465_1
            queryRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819381_1
        }
        if (reqDto != null && reqDto.getRedisBusinessDataResList() != null && !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())) {
            queryRedisBusinessDataReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517682_1
        }

        /*M2-查询redis业务数据对象列表（特殊方法）[8391]   */
        Assert.isNull(queryRedisBusinessDataReq.getDataObjectBatchCode(), "D2-查询redis业务数据对象列表(公共)-M2-查询redis业务数据对象列表（特殊方法）-数据对象批次标识不能为空", false);
        Assert.isNull(queryRedisBusinessDataReq.getBusinessDataObject(), "D2-查询redis业务数据对象列表(公共)-M2-查询redis业务数据对象列表（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(queryRedisBusinessDataReq.getRedisDataObjectCatalogue(), "D2-查询redis业务数据对象列表(公共)-M2-查询redis业务数据对象列表（特殊方法）-Redis数据对象目录不能为空", false);
        queryRedisBusinessDataRes = nbInterfaceMode.queryRedisBusinessDataList(queryRedisBusinessDataReq);


        queryRedisBusinessDataRes_1 = queryRedisBusinessDataRes;

        QueryRedisBusinessDataListComRespDto retData = new QueryRedisBusinessDataListComRespDto();
        if (queryRedisBusinessDataRes_1 != null) {
            retData.setRedisBusinessDataResList(queryRedisBusinessDataRes_1.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517686_1
        }


        return retData;
    }

    /**
     * D2-删除redis业务数据对象(公共)[8397]
     * gen by moon at 5/31/2024, 8:33:50 PM
     */
    @Trace(operationName = "D2-删除redis业务数据对象(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataCom(DeleteRedisBusinessDataComReqDto reqDto) {


        //步骤0: M2-删除redis业务数据对象（特殊方法） - deleteRedisBusinessData
        //ModelCode: deleteRedisBusinessData
        DeleteRedisBusinessDataRespDto deleteRedisBusinessDataRes = null;
        DeleteRedisBusinessDataReqDto deleteRedisBusinessDataReq = new DeleteRedisBusinessDataReqDto();
        if (reqDto != null) {
            deleteRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1820568_1
            deleteRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517510_1
            deleteRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517470_1
            deleteRedisBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1517511_1
        }
        if (reqDto != null && reqDto.getFieldDataList() != null && !CollectionUtil.isEmpty(reqDto.getFieldDataList())) {
            deleteRedisBusinessDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517471_1
        }

        /*M2-删除redis业务数据对象（特殊方法）[8392]   */
        Assert.isNull(deleteRedisBusinessDataReq.getRedisDataObjectCatalogue(), "D2-删除redis业务数据对象(公共)-M2-删除redis业务数据对象（特殊方法）-Redis数据对象目录不能为空", false);
        Assert.isNull(deleteRedisBusinessDataReq.getBusinessDataObject(), "D2-删除redis业务数据对象(公共)-M2-删除redis业务数据对象（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(deleteRedisBusinessDataReq.getIsDataList(), "D2-删除redis业务数据对象(公共)-M2-删除redis业务数据对象（特殊方法）-是否是数据集对象不能为空", false);
        deleteRedisBusinessDataRes = nbInterfaceMode.deleteRedisBusinessData(deleteRedisBusinessDataReq);


        DeleteRedisBusinessDataComRespDto retData = new DeleteRedisBusinessDataComRespDto();


        return retData;
    }

    /**
     * D2-查询redis业务数据对象详情(公共)[8401]
     * gen by moon at 5/31/2024, 8:34:04 PM
     */
    @Trace(operationName = "D2-查询redis业务数据对象详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRedisBusinessDataDetailComRespDto queryRedisBusinessDataDetailCom(QueryRedisBusinessDataDetailComReqDto reqDto) {


        QueryRedisBusinessDataDetailRespDto queryRedisBusinessDataObjectRes_1 = null;
//步骤0: M2-查询redis业务数据对象详情（特殊方法） - queryRedisBusinessDataDetail
        //ModelCode: queryRedisBusinessDataObject
        QueryRedisBusinessDataDetailRespDto queryRedisBusinessDataObjectRes = null;
        QueryRedisBusinessDataDetailReqDto queryRedisBusinessDataObjectReq = new QueryRedisBusinessDataDetailReqDto();
        if (reqDto != null) {
            queryRedisBusinessDataObjectReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1517747_1
            queryRedisBusinessDataObjectReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1517746_1
            queryRedisBusinessDataObjectReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819376_1
        }
        if (reqDto != null && reqDto.getRedisBusinessDataResList() != null && !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())) {
            queryRedisBusinessDataObjectReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1517745_1
        }

        /*M2-查询redis业务数据对象详情（特殊方法）[8402]   */
        Assert.isNull(queryRedisBusinessDataObjectReq.getDataObjectBatchCode(), "D2-查询redis业务数据对象详情(公共)-M2-查询redis业务数据对象详情（特殊方法）-数据对象批次标识不能为空", false);
        Assert.isNull(queryRedisBusinessDataObjectReq.getBusinessDataObject(), "D2-查询redis业务数据对象详情(公共)-M2-查询redis业务数据对象详情（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(queryRedisBusinessDataObjectReq.getRedisDataObjectCatalogue(), "D2-查询redis业务数据对象详情(公共)-M2-查询redis业务数据对象详情（特殊方法）-Redis数据对象目录不能为空", false);
        queryRedisBusinessDataObjectRes = nbInterfaceMode.queryRedisBusinessDataDetail(queryRedisBusinessDataObjectReq);


        queryRedisBusinessDataObjectRes_1 = queryRedisBusinessDataObjectRes;

        QueryRedisBusinessDataDetailComRespDto retData = new QueryRedisBusinessDataDetailComRespDto();
        if (queryRedisBusinessDataObjectRes_1 != null) {
            retData.setCustomField1(queryRedisBusinessDataObjectRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1517801_1
            retData.setCustomField2(queryRedisBusinessDataObjectRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1517802_1
            retData.setCustomField3(queryRedisBusinessDataObjectRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1517803_1
            retData.setCustomField4(queryRedisBusinessDataObjectRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1517804_1
            retData.setCustomField5(queryRedisBusinessDataObjectRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1517805_1
            retData.setCustomField7(queryRedisBusinessDataObjectRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1517806_1
            retData.setCustomField6(queryRedisBusinessDataObjectRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1517807_1
            retData.setCustomField8(queryRedisBusinessDataObjectRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1517808_1
            retData.setCustomField9(queryRedisBusinessDataObjectRes_1.getCustomField9());//SimpleFieldAssign//sourceId:1517809_1
            retData.setCustomField10(queryRedisBusinessDataObjectRes_1.getCustomField10());//SimpleFieldAssign//sourceId:1517810_1
            retData.setCustomField11(queryRedisBusinessDataObjectRes_1.getCustomField11());//SimpleFieldAssign//sourceId:1517811_1
            retData.setCustomField12(queryRedisBusinessDataObjectRes_1.getCustomField12());//SimpleFieldAssign//sourceId:1517812_1
            retData.setCustomField13(queryRedisBusinessDataObjectRes_1.getCustomField13());//SimpleFieldAssign//sourceId:1517813_1
            retData.setCustomField14(queryRedisBusinessDataObjectRes_1.getCustomField14());//SimpleFieldAssign//sourceId:1517814_1
            retData.setCustomField15(queryRedisBusinessDataObjectRes_1.getCustomField15());//SimpleFieldAssign//sourceId:1517815_1
            retData.setCustomField16(queryRedisBusinessDataObjectRes_1.getCustomField16());//SimpleFieldAssign//sourceId:1517816_1
            retData.setCustomField17(queryRedisBusinessDataObjectRes_1.getCustomField17());//SimpleFieldAssign//sourceId:1517817_1
            retData.setCustomField18(queryRedisBusinessDataObjectRes_1.getCustomField18());//SimpleFieldAssign//sourceId:1517818_1
            retData.setCustomField19(queryRedisBusinessDataObjectRes_1.getCustomField19());//SimpleFieldAssign//sourceId:1517819_1
            retData.setCustomField20(queryRedisBusinessDataObjectRes_1.getCustomField20());//SimpleFieldAssign//sourceId:1517820_1
            retData.setCustomField21(queryRedisBusinessDataObjectRes_1.getCustomField21());//SimpleFieldAssign//sourceId:1517821_1
            retData.setCustomField22(queryRedisBusinessDataObjectRes_1.getCustomField22());//SimpleFieldAssign//sourceId:1517822_1
            retData.setCustomField23(queryRedisBusinessDataObjectRes_1.getCustomField23());//SimpleFieldAssign//sourceId:1517823_1
            retData.setCustomField24(queryRedisBusinessDataObjectRes_1.getCustomField24());//SimpleFieldAssign//sourceId:1517824_1
            retData.setCustomField25(queryRedisBusinessDataObjectRes_1.getCustomField25());//SimpleFieldAssign//sourceId:1517825_1
            retData.setCustomField26(queryRedisBusinessDataObjectRes_1.getCustomField26());//SimpleFieldAssign//sourceId:1517826_1
            retData.setCustomField27(queryRedisBusinessDataObjectRes_1.getCustomField27());//SimpleFieldAssign//sourceId:1517827_1
            retData.setCustomField28(queryRedisBusinessDataObjectRes_1.getCustomField28());//SimpleFieldAssign//sourceId:1517828_1
            retData.setCustomField29(queryRedisBusinessDataObjectRes_1.getCustomField29());//SimpleFieldAssign//sourceId:1517829_1
            retData.setCustomField30(queryRedisBusinessDataObjectRes_1.getCustomField30());//SimpleFieldAssign//sourceId:1517830_1
            retData.setCustomField31(queryRedisBusinessDataObjectRes_1.getCustomField31());//SimpleFieldAssign//sourceId:1517831_1
            retData.setCustomField32(queryRedisBusinessDataObjectRes_1.getCustomField32());//SimpleFieldAssign//sourceId:1517832_1
            retData.setCustomField33(queryRedisBusinessDataObjectRes_1.getCustomField33());//SimpleFieldAssign//sourceId:1517833_1
            retData.setCustomField34(queryRedisBusinessDataObjectRes_1.getCustomField34());//SimpleFieldAssign//sourceId:1517834_1
            retData.setCustomField35(queryRedisBusinessDataObjectRes_1.getCustomField35());//SimpleFieldAssign//sourceId:1517835_1
            retData.setCustomField36(queryRedisBusinessDataObjectRes_1.getCustomField36());//SimpleFieldAssign//sourceId:1517836_1
            retData.setCustomField37(queryRedisBusinessDataObjectRes_1.getCustomField37());//SimpleFieldAssign//sourceId:1517837_1
            retData.setCustomField38(queryRedisBusinessDataObjectRes_1.getCustomField38());//SimpleFieldAssign//sourceId:1517838_1
            retData.setCustomField39(queryRedisBusinessDataObjectRes_1.getCustomField39());//SimpleFieldAssign//sourceId:1517839_1
            retData.setCustomField40(queryRedisBusinessDataObjectRes_1.getCustomField40());//SimpleFieldAssign//sourceId:1517840_1
            retData.setCustomField41(queryRedisBusinessDataObjectRes_1.getCustomField41());//SimpleFieldAssign//sourceId:1517841_1
            retData.setCustomField42(queryRedisBusinessDataObjectRes_1.getCustomField42());//SimpleFieldAssign//sourceId:1517842_1
            retData.setCustomField43(queryRedisBusinessDataObjectRes_1.getCustomField43());//SimpleFieldAssign//sourceId:1517843_1
            retData.setCustomField44(queryRedisBusinessDataObjectRes_1.getCustomField44());//SimpleFieldAssign//sourceId:1517844_1
            retData.setCustomField45(queryRedisBusinessDataObjectRes_1.getCustomField45());//SimpleFieldAssign//sourceId:1517845_1
            retData.setCustomField46(queryRedisBusinessDataObjectRes_1.getCustomField46());//SimpleFieldAssign//sourceId:1517846_1
            retData.setCustomField47(queryRedisBusinessDataObjectRes_1.getCustomField47());//SimpleFieldAssign//sourceId:1517847_1
            retData.setCustomField48(queryRedisBusinessDataObjectRes_1.getCustomField48());//SimpleFieldAssign//sourceId:1517848_1
            retData.setCustomField49(queryRedisBusinessDataObjectRes_1.getCustomField49());//SimpleFieldAssign//sourceId:1517849_1
            retData.setCustomField50(queryRedisBusinessDataObjectRes_1.getCustomField50());//SimpleFieldAssign//sourceId:1517850_1
        }


        return retData;
    }

    /**
     * D2-分析单字段批量转数据集(公共)[8405]
     * gen by moon at 10/23/2024, 6:13:37 PM
     */
    @Trace(operationName = "D2-分析单字段批量转数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisFieldBatchDataComRespDto analysisFieldBatchDataCom(AnalysisFieldBatchDataComReqDto reqDto) {


        AnalysisFieldBatchDataRespDto fieldBatchDataRes_1 = null;
//步骤0: M2-分析单字段批量转数据集（特殊方法） - analysisFieldBatchData
        //ModelCode: fieldBatchData
        AnalysisFieldBatchDataRespDto fieldBatchDataRes = null;
        AnalysisFieldBatchDataReqDto fieldBatchDataReq = new AnalysisFieldBatchDataReqDto();
        if (reqDto != null) {
            fieldBatchDataReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:1518019_1
            fieldBatchDataReq.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1518020_1
            fieldBatchDataReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:1518021_1
            fieldBatchDataReq.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1518022_1
            fieldBatchDataReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:1518023_1
            fieldBatchDataReq.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1518024_1
            fieldBatchDataReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:1518025_1
            fieldBatchDataReq.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:1518026_1
            fieldBatchDataReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:1518027_1
            fieldBatchDataReq.setCustomFieldValue5(reqDto.getCustomFieldValue5());//SimpleFieldAssign//sourceId:1518028_1
            fieldBatchDataReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:1518029_1
            fieldBatchDataReq.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:1518030_1
            fieldBatchDataReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:1518031_1
            fieldBatchDataReq.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:1518032_1
            fieldBatchDataReq.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:1518033_1
            fieldBatchDataReq.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:1518034_1
            fieldBatchDataReq.setCustomField9(reqDto.getCustomField9());//SimpleFieldAssign//sourceId:1518035_1
            fieldBatchDataReq.setCustomFieldValue9(reqDto.getCustomFieldValue9());//SimpleFieldAssign//sourceId:1518036_1
            fieldBatchDataReq.setCustomField10(reqDto.getCustomField10());//SimpleFieldAssign//sourceId:1518037_1
            fieldBatchDataReq.setCustomFieldValue10(reqDto.getCustomFieldValue10());//SimpleFieldAssign//sourceId:1518038_1
            fieldBatchDataReq.setCustomField11(reqDto.getCustomField11());//SimpleFieldAssign//sourceId:1518039_1
            fieldBatchDataReq.setCustomFieldValue11(reqDto.getCustomFieldValue11());//SimpleFieldAssign//sourceId:1518040_1
            fieldBatchDataReq.setCustomField12(reqDto.getCustomField12());//SimpleFieldAssign//sourceId:1518041_1
            fieldBatchDataReq.setCustomFieldValue12(reqDto.getCustomFieldValue12());//SimpleFieldAssign//sourceId:1518042_1
            fieldBatchDataReq.setCustomField13(reqDto.getCustomField13());//SimpleFieldAssign//sourceId:1518043_1
            fieldBatchDataReq.setCustomFieldValue13(reqDto.getCustomFieldValue13());//SimpleFieldAssign//sourceId:1518044_1
            fieldBatchDataReq.setCustomField14(reqDto.getCustomField14());//SimpleFieldAssign//sourceId:1518045_1
            fieldBatchDataReq.setCustomFieldValue14(reqDto.getCustomFieldValue14());//SimpleFieldAssign//sourceId:1518046_1
            fieldBatchDataReq.setCustomField15(reqDto.getCustomField15());//SimpleFieldAssign//sourceId:1518047_1
            fieldBatchDataReq.setCustomFieldValue15(reqDto.getCustomFieldValue15());//SimpleFieldAssign//sourceId:1518048_1
            fieldBatchDataReq.setCustomField16(reqDto.getCustomField16());//SimpleFieldAssign//sourceId:1518049_1
            fieldBatchDataReq.setCustomFieldValue16(reqDto.getCustomFieldValue16());//SimpleFieldAssign//sourceId:1518050_1
            fieldBatchDataReq.setCustomField17(reqDto.getCustomField17());//SimpleFieldAssign//sourceId:1518051_1
            fieldBatchDataReq.setCustomFieldValue17(reqDto.getCustomFieldValue17());//SimpleFieldAssign//sourceId:1518052_1
            fieldBatchDataReq.setCustomField18(reqDto.getCustomField18());//SimpleFieldAssign//sourceId:1518053_1
            fieldBatchDataReq.setCustomFieldValue18(reqDto.getCustomFieldValue18());//SimpleFieldAssign//sourceId:1518054_1
            fieldBatchDataReq.setCustomField19(reqDto.getCustomField19());//SimpleFieldAssign//sourceId:1518055_1
            fieldBatchDataReq.setCustomFieldValue19(reqDto.getCustomFieldValue19());//SimpleFieldAssign//sourceId:1518095_1
            fieldBatchDataReq.setCustomField20(reqDto.getCustomField20());//SimpleFieldAssign//sourceId:1518056_1
            fieldBatchDataReq.setCustomFieldValue20(reqDto.getCustomFieldValue20());//SimpleFieldAssign//sourceId:1518096_1
            fieldBatchDataReq.setCustomField21(reqDto.getCustomField21());//SimpleFieldAssign//sourceId:1518057_1
            fieldBatchDataReq.setCustomFieldValue21(reqDto.getCustomFieldValue21());//SimpleFieldAssign//sourceId:1518097_1
            fieldBatchDataReq.setCustomField22(reqDto.getCustomField22());//SimpleFieldAssign//sourceId:1518058_1
            fieldBatchDataReq.setCustomFieldValue22(reqDto.getCustomFieldValue22());//SimpleFieldAssign//sourceId:1518098_1
            fieldBatchDataReq.setCustomField23(reqDto.getCustomField23());//SimpleFieldAssign//sourceId:1518059_1
            fieldBatchDataReq.setCustomFieldValue23(reqDto.getCustomFieldValue23());//SimpleFieldAssign//sourceId:1518099_1
            fieldBatchDataReq.setCustomField24(reqDto.getCustomField24());//SimpleFieldAssign//sourceId:1518060_1
            fieldBatchDataReq.setCustomFieldValue24(reqDto.getCustomFieldValue24());//SimpleFieldAssign//sourceId:1518100_1
            fieldBatchDataReq.setCustomField25(reqDto.getCustomField25());//SimpleFieldAssign//sourceId:1518061_1
            fieldBatchDataReq.setCustomFieldValue25(reqDto.getCustomFieldValue25());//SimpleFieldAssign//sourceId:1518101_1
            fieldBatchDataReq.setCustomField26(reqDto.getCustomField26());//SimpleFieldAssign//sourceId:1518062_1
            fieldBatchDataReq.setCustomFieldValue26(reqDto.getCustomFieldValue26());//SimpleFieldAssign//sourceId:1518102_1
            fieldBatchDataReq.setCustomField27(reqDto.getCustomField27());//SimpleFieldAssign//sourceId:1518063_1
            fieldBatchDataReq.setCustomFieldValue27(reqDto.getCustomFieldValue27());//SimpleFieldAssign//sourceId:1518103_1
            fieldBatchDataReq.setCustomField28(reqDto.getCustomField28());//SimpleFieldAssign//sourceId:1518064_1
            fieldBatchDataReq.setCustomFieldValue28(reqDto.getCustomFieldValue28());//SimpleFieldAssign//sourceId:1518104_1
            fieldBatchDataReq.setCustomField29(reqDto.getCustomField29());//SimpleFieldAssign//sourceId:1518065_1
            fieldBatchDataReq.setCustomFieldValue29(reqDto.getCustomFieldValue29());//SimpleFieldAssign//sourceId:1518105_1
            fieldBatchDataReq.setCustomField30(reqDto.getCustomField30());//SimpleFieldAssign//sourceId:1518066_1
            fieldBatchDataReq.setCustomFieldValue30(reqDto.getCustomFieldValue30());//SimpleFieldAssign//sourceId:1518106_1
            fieldBatchDataReq.setCustomField31(reqDto.getCustomField31());//SimpleFieldAssign//sourceId:1518067_1
            fieldBatchDataReq.setCustomFieldValue31(reqDto.getCustomFieldValue31());//SimpleFieldAssign//sourceId:1518107_1
            fieldBatchDataReq.setCustomField32(reqDto.getCustomField32());//SimpleFieldAssign//sourceId:1518068_1
            fieldBatchDataReq.setCustomFieldValue32(reqDto.getCustomFieldValue32());//SimpleFieldAssign//sourceId:1518108_1
            fieldBatchDataReq.setCustomField33(reqDto.getCustomField33());//SimpleFieldAssign//sourceId:1518069_1
            fieldBatchDataReq.setCustomFieldValue33(reqDto.getCustomFieldValue33());//SimpleFieldAssign//sourceId:1518109_1
            fieldBatchDataReq.setCustomField34(reqDto.getCustomField34());//SimpleFieldAssign//sourceId:1518070_1
            fieldBatchDataReq.setCustomFieldValue34(reqDto.getCustomFieldValue34());//SimpleFieldAssign//sourceId:1518110_1
            fieldBatchDataReq.setCustomField35(reqDto.getCustomField35());//SimpleFieldAssign//sourceId:1518071_1
            fieldBatchDataReq.setCustomFieldValue35(reqDto.getCustomFieldValue35());//SimpleFieldAssign//sourceId:1518111_1
            fieldBatchDataReq.setCustomField36(reqDto.getCustomField36());//SimpleFieldAssign//sourceId:1518072_1
            fieldBatchDataReq.setCustomFieldValue36(reqDto.getCustomFieldValue36());//SimpleFieldAssign//sourceId:1518112_1
            fieldBatchDataReq.setCustomField37(reqDto.getCustomField37());//SimpleFieldAssign//sourceId:1518073_1
            fieldBatchDataReq.setCustomFieldValue37(reqDto.getCustomFieldValue37());//SimpleFieldAssign//sourceId:1518113_1
            fieldBatchDataReq.setCustomField38(reqDto.getCustomField38());//SimpleFieldAssign//sourceId:1518074_1
            fieldBatchDataReq.setCustomFieldValue38(reqDto.getCustomFieldValue38());//SimpleFieldAssign//sourceId:1518114_1
            fieldBatchDataReq.setCustomField39(reqDto.getCustomField39());//SimpleFieldAssign//sourceId:1518075_1
            fieldBatchDataReq.setCustomFieldValue39(reqDto.getCustomFieldValue39());//SimpleFieldAssign//sourceId:1518115_1
            fieldBatchDataReq.setCustomField40(reqDto.getCustomField40());//SimpleFieldAssign//sourceId:1518076_1
            fieldBatchDataReq.setCustomFieldValue40(reqDto.getCustomFieldValue40());//SimpleFieldAssign//sourceId:1518116_1
            fieldBatchDataReq.setCustomField41(reqDto.getCustomField41());//SimpleFieldAssign//sourceId:1518077_1
            fieldBatchDataReq.setCustomFieldValue41(reqDto.getCustomFieldValue41());//SimpleFieldAssign//sourceId:1518117_1
            fieldBatchDataReq.setCustomField42(reqDto.getCustomField42());//SimpleFieldAssign//sourceId:1518078_1
            fieldBatchDataReq.setCustomFieldValue42(reqDto.getCustomFieldValue42());//SimpleFieldAssign//sourceId:1518118_1
            fieldBatchDataReq.setCustomField43(reqDto.getCustomField43());//SimpleFieldAssign//sourceId:1518079_1
            fieldBatchDataReq.setCustomFieldValue43(reqDto.getCustomFieldValue43());//SimpleFieldAssign//sourceId:1518087_1
            fieldBatchDataReq.setCustomField44(reqDto.getCustomField44());//SimpleFieldAssign//sourceId:1518080_1
            fieldBatchDataReq.setCustomFieldValue44(reqDto.getCustomFieldValue44());//SimpleFieldAssign//sourceId:1518088_1
            fieldBatchDataReq.setCustomField45(reqDto.getCustomField45());//SimpleFieldAssign//sourceId:1518081_1
            fieldBatchDataReq.setCustomFieldValue45(reqDto.getCustomFieldValue45());//SimpleFieldAssign//sourceId:1518089_1
            fieldBatchDataReq.setCustomField46(reqDto.getCustomField46());//SimpleFieldAssign//sourceId:1518082_1
            fieldBatchDataReq.setCustomFieldValue46(reqDto.getCustomFieldValue46());//SimpleFieldAssign//sourceId:1518090_1
            fieldBatchDataReq.setCustomField47(reqDto.getCustomField47());//SimpleFieldAssign//sourceId:1518083_1
            fieldBatchDataReq.setCustomFieldValue47(reqDto.getCustomFieldValue47());//SimpleFieldAssign//sourceId:1518091_1
            fieldBatchDataReq.setCustomField48(reqDto.getCustomField48());//SimpleFieldAssign//sourceId:1518084_1
            fieldBatchDataReq.setCustomFieldValue48(reqDto.getCustomFieldValue48());//SimpleFieldAssign//sourceId:1518092_1
            fieldBatchDataReq.setCustomField49(reqDto.getCustomField49());//SimpleFieldAssign//sourceId:1518085_1
            fieldBatchDataReq.setCustomFieldValue49(reqDto.getCustomFieldValue49());//SimpleFieldAssign//sourceId:1518093_1
            fieldBatchDataReq.setCustomField50(reqDto.getCustomField50());//SimpleFieldAssign//sourceId:1518086_1
            fieldBatchDataReq.setCustomFieldValue50(reqDto.getCustomFieldValue50());//SimpleFieldAssign//sourceId:1518094_1
            fieldBatchDataReq.setCustomField51(reqDto.getCustomField51());//SimpleFieldAssign//sourceId:1834665_1
            fieldBatchDataReq.setCustomFieldValue51(reqDto.getCustomFieldValue51());//SimpleFieldAssign//sourceId:1834666_1
            fieldBatchDataReq.setCustomField52(reqDto.getCustomField52());//SimpleFieldAssign//sourceId:1834667_1
            fieldBatchDataReq.setCustomFieldValue52(reqDto.getCustomFieldValue52());//SimpleFieldAssign//sourceId:1834668_1
            fieldBatchDataReq.setCustomField53(reqDto.getCustomField53());//SimpleFieldAssign//sourceId:1834669_1
            fieldBatchDataReq.setCustomFieldValue53(reqDto.getCustomFieldValue53());//SimpleFieldAssign//sourceId:1834670_1
            fieldBatchDataReq.setCustomField54(reqDto.getCustomField54());//SimpleFieldAssign//sourceId:1834671_1
            fieldBatchDataReq.setCustomFieldValue54(reqDto.getCustomFieldValue54());//SimpleFieldAssign//sourceId:1834672_1
            fieldBatchDataReq.setCustomField55(reqDto.getCustomField55());//SimpleFieldAssign//sourceId:1834673_1
            fieldBatchDataReq.setCustomFieldValue55(reqDto.getCustomFieldValue55());//SimpleFieldAssign//sourceId:1834674_1
            fieldBatchDataReq.setCustomField56(reqDto.getCustomField56());//SimpleFieldAssign//sourceId:1834675_1
            fieldBatchDataReq.setCustomFieldValue56(reqDto.getCustomFieldValue56());//SimpleFieldAssign//sourceId:1834676_1
            fieldBatchDataReq.setCustomField57(reqDto.getCustomField57());//SimpleFieldAssign//sourceId:2022541_1
            fieldBatchDataReq.setCustomFieldValue57(reqDto.getCustomFieldValue57());//SimpleFieldAssign//sourceId:2022542_1
            fieldBatchDataReq.setCustomField58(reqDto.getCustomField58());//SimpleFieldAssign//sourceId:2022543_1
            fieldBatchDataReq.setCustomFieldValue58(reqDto.getCustomFieldValue58());//SimpleFieldAssign//sourceId:2022544_1
            fieldBatchDataReq.setCustomField59(reqDto.getCustomField59());//SimpleFieldAssign//sourceId:2022545_1
            fieldBatchDataReq.setCustomFieldValue59(reqDto.getCustomFieldValue59());//SimpleFieldAssign//sourceId:2022546_1
            fieldBatchDataReq.setCustomField60(reqDto.getCustomField60());//SimpleFieldAssign//sourceId:2022547_1
            fieldBatchDataReq.setCustomFieldValue60(reqDto.getCustomFieldValue60());//SimpleFieldAssign//sourceId:2022548_1
        }

        /*M2-分析单字段批量转数据集（特殊方法）[8403]   */

        fieldBatchDataRes = nbInterfaceMode.analysisFieldBatchData(fieldBatchDataReq);


        fieldBatchDataRes_1 = fieldBatchDataRes;

        AnalysisFieldBatchDataComRespDto retData = new AnalysisFieldBatchDataComRespDto();
        if (fieldBatchDataRes_1 != null) {
            retData.setFieldBatchDataList(fieldBatchDataRes_1.getFieldBatchDataList().stream().map(item -> BeanUtil.toBean(item, FieldBatchDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1518220_1
        }


        return retData;
    }

    /**
     * D2-查询入参redis业务数据对象列表(公共)[8441]
     * gen by moon at 5/31/2024, 8:34:25 PM
     */
    @Trace(operationName = "D2-查询入参redis业务数据对象列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRefRedisBusinessDataListComRespDto queryRefRedisBusinessDataListCom(QueryRefRedisBusinessDataListComReqDto reqDto) {


        QueryRefRedisBusinessDataListRespDto queryRedisBusinessSomeDataRes_1 = null;
//步骤0: M2-查询入参redis业务数据对象列表（特殊方法） - queryRefRedisBusinessDataList
        //ModelCode: queryRedisBusinessSomeData
        QueryRefRedisBusinessDataListRespDto queryRedisBusinessSomeDataRes = null;
        QueryRefRedisBusinessDataListReqDto queryRedisBusinessSomeDataReq = new QueryRefRedisBusinessDataListReqDto();
        if (reqDto != null) {
            queryRedisBusinessSomeDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1525990_1
            queryRedisBusinessSomeDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1525991_1
            queryRedisBusinessSomeDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819386_1
            queryRedisBusinessSomeDataReq.setBatchQueryRefDataFieldName(reqDto.getBatchQueryRefDataFieldName());//SimpleFieldAssign//sourceId:1536581_1
            queryRedisBusinessSomeDataReq.setRefRedisBusinessDataList(reqDto.getRefRedisBusinessDataList());//list-field-assign//sourceId:1527594_1
            queryRedisBusinessSomeDataReq.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1525994_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1537497_1
            queryRedisBusinessSomeDataReq.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1525995_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1537498_1
            queryRedisBusinessSomeDataReq.setRefCustomField3(reqDto.getRefCustomField3());//SimpleFieldAssign//sourceId:1525996_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue3(reqDto.getRefCustomFieldValue3());//SimpleFieldAssign//sourceId:1537499_1
            queryRedisBusinessSomeDataReq.setRefCustomField4(reqDto.getRefCustomField4());//SimpleFieldAssign//sourceId:1525997_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue4(reqDto.getRefCustomFieldValue4());//SimpleFieldAssign//sourceId:1537500_1
            queryRedisBusinessSomeDataReq.setRefCustomField5(reqDto.getRefCustomField5());//SimpleFieldAssign//sourceId:1525998_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue5(reqDto.getRefCustomFieldValue5());//SimpleFieldAssign//sourceId:1537501_1
            queryRedisBusinessSomeDataReq.setRefCustomField6(reqDto.getRefCustomField6());//SimpleFieldAssign//sourceId:1525999_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue6(reqDto.getRefCustomFieldValue6());//SimpleFieldAssign//sourceId:1537502_1
            queryRedisBusinessSomeDataReq.setRefCustomField7(reqDto.getRefCustomField7());//SimpleFieldAssign//sourceId:1526000_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue7(reqDto.getRefCustomFieldValue7());//SimpleFieldAssign//sourceId:1537503_1
            queryRedisBusinessSomeDataReq.setRefCustomField8(reqDto.getRefCustomField8());//SimpleFieldAssign//sourceId:1526001_1
            queryRedisBusinessSomeDataReq.setRefCustomFieldValue8(reqDto.getRefCustomFieldValue8());//SimpleFieldAssign//sourceId:1537504_1
        }
        if (reqDto != null && reqDto.getRedisBusinessDataResList() != null && !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())) {
            queryRedisBusinessSomeDataReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1525992_1
        }

        /*M2-查询入参redis业务数据对象列表（特殊方法）[8442]   */
        Assert.isNull(queryRedisBusinessSomeDataReq.getBusinessDataObject(), "D2-查询入参redis业务数据对象列表(公共)-M2-查询入参redis业务数据对象列表（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(queryRedisBusinessSomeDataReq.getDataObjectBatchCode(), "D2-查询入参redis业务数据对象列表(公共)-M2-查询入参redis业务数据对象列表（特殊方法）-数据对象批次标识不能为空", false);
        Assert.isNull(queryRedisBusinessSomeDataReq.getRedisDataObjectCatalogue(), "D2-查询入参redis业务数据对象列表(公共)-M2-查询入参redis业务数据对象列表（特殊方法）-Redis数据对象目录不能为空", false);
        queryRedisBusinessSomeDataRes = nbInterfaceMode.queryRefRedisBusinessDataList(queryRedisBusinessSomeDataReq);


        queryRedisBusinessSomeDataRes_1 = queryRedisBusinessSomeDataRes;

        QueryRefRedisBusinessDataListComRespDto retData = new QueryRefRedisBusinessDataListComRespDto();
        if (queryRedisBusinessSomeDataRes_1 != null) {
            retData.setRedisBusinessDataResList(queryRedisBusinessSomeDataRes_1.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1526013_1
        }


        return retData;
    }

    /**
     * D2-查询入参redis业务数据对象详情(公共)[8475]
     * gen by moon at 6/3/2024, 10:53:33 PM
     */
    @Trace(operationName = "D2-查询入参redis业务数据对象详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRefRedisBusinessDataDetailComRespDto queryRefRedisBusinessDataDetailCom(QueryRefRedisBusinessDataDetailComReqDto reqDto) {


        QueryRefRedisBusinessDataDetailRespDto queryRedisBusinessOneDataRes_1 = null;
//步骤0: M2-查询入参redis业务数据对象详情（特殊方法） - queryRefRedisBusinessDataDetail
        //ModelCode: queryRedisBusinessOneData
        QueryRefRedisBusinessDataDetailRespDto queryRedisBusinessOneDataRes = null;
        QueryRefRedisBusinessDataDetailReqDto queryRedisBusinessOneDataReq = new QueryRefRedisBusinessDataDetailReqDto();
        if (reqDto != null) {
            queryRedisBusinessOneDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1533983_1
            queryRedisBusinessOneDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819391_1
            queryRedisBusinessOneDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1533984_1
            queryRedisBusinessOneDataReq.setRedisParamSortType(reqDto.getRedisParamSortType());//SimpleFieldAssign//sourceId:1846404_1
            queryRedisBusinessOneDataReq.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1533985_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1536787_1
            queryRedisBusinessOneDataReq.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1533986_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1536788_1
            queryRedisBusinessOneDataReq.setRefCustomField3(reqDto.getRefCustomField3());//SimpleFieldAssign//sourceId:1533987_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue3(reqDto.getRefCustomFieldValue3());//SimpleFieldAssign//sourceId:1536789_1
            queryRedisBusinessOneDataReq.setRefCustomField4(reqDto.getRefCustomField4());//SimpleFieldAssign//sourceId:1533988_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue4(reqDto.getRefCustomFieldValue4());//SimpleFieldAssign//sourceId:1536790_1
            queryRedisBusinessOneDataReq.setRefCustomField5(reqDto.getRefCustomField5());//SimpleFieldAssign//sourceId:1533989_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue5(reqDto.getRefCustomFieldValue5());//SimpleFieldAssign//sourceId:1536791_1
            queryRedisBusinessOneDataReq.setRefCustomField6(reqDto.getRefCustomField6());//SimpleFieldAssign//sourceId:1533990_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue6(reqDto.getRefCustomFieldValue6());//SimpleFieldAssign//sourceId:1536792_1
            queryRedisBusinessOneDataReq.setRefCustomField7(reqDto.getRefCustomField7());//SimpleFieldAssign//sourceId:1533991_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue7(reqDto.getRefCustomFieldValue7());//SimpleFieldAssign//sourceId:1536793_1
            queryRedisBusinessOneDataReq.setRefCustomField8(reqDto.getRefCustomField8());//SimpleFieldAssign//sourceId:1533992_1
            queryRedisBusinessOneDataReq.setRefCustomFieldValue8(reqDto.getRefCustomFieldValue8());//SimpleFieldAssign//sourceId:1536794_1
        }
        if (reqDto != null && reqDto.getRedisBusinessDataResList() != null && !CollectionUtil.isEmpty(reqDto.getRedisBusinessDataResList())) {
            queryRedisBusinessOneDataReq.setRedisBusinessDataResList(reqDto.getRedisBusinessDataResList().stream().map(item -> BeanUtil.toBean(item, RedisBusinessDataResDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1533993_1
        }

        /*M2-查询入参redis业务数据对象详情（特殊方法）[8474]   */
        Assert.isNull(queryRedisBusinessOneDataReq.getBusinessDataObject(), "D2-查询入参redis业务数据对象详情(公共)-M2-查询入参redis业务数据对象详情（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(queryRedisBusinessOneDataReq.getRedisDataObjectCatalogue(), "D2-查询入参redis业务数据对象详情(公共)-M2-查询入参redis业务数据对象详情（特殊方法）-Redis数据对象目录不能为空", false);
        queryRedisBusinessOneDataRes = nbInterfaceMode.queryRefRedisBusinessDataDetail(queryRedisBusinessOneDataReq);


        queryRedisBusinessOneDataRes_1 = queryRedisBusinessOneDataRes;

        QueryRefRedisBusinessDataDetailComRespDto retData = new QueryRefRedisBusinessDataDetailComRespDto();
        if (queryRedisBusinessOneDataRes_1 != null) {
            retData.setCustomField1(queryRedisBusinessOneDataRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1534139_1
            retData.setCustomField2(queryRedisBusinessOneDataRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1534140_1
            retData.setCustomField3(queryRedisBusinessOneDataRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1534141_1
            retData.setCustomField4(queryRedisBusinessOneDataRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1534142_1
            retData.setCustomField5(queryRedisBusinessOneDataRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1534143_1
            retData.setCustomField6(queryRedisBusinessOneDataRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1534144_1
            retData.setCustomField7(queryRedisBusinessOneDataRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1534145_1
            retData.setCustomField8(queryRedisBusinessOneDataRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1534146_1
            retData.setCustomField9(queryRedisBusinessOneDataRes_1.getCustomField9());//SimpleFieldAssign//sourceId:1534147_1
            retData.setCustomField10(queryRedisBusinessOneDataRes_1.getCustomField10());//SimpleFieldAssign//sourceId:1534148_1
            retData.setCustomField11(queryRedisBusinessOneDataRes_1.getCustomField11());//SimpleFieldAssign//sourceId:1534149_1
            retData.setCustomField12(queryRedisBusinessOneDataRes_1.getCustomField12());//SimpleFieldAssign//sourceId:1534150_1
            retData.setCustomField13(queryRedisBusinessOneDataRes_1.getCustomField13());//SimpleFieldAssign//sourceId:1534151_1
            retData.setCustomField14(queryRedisBusinessOneDataRes_1.getCustomField14());//SimpleFieldAssign//sourceId:1534152_1
            retData.setCustomField15(queryRedisBusinessOneDataRes_1.getCustomField15());//SimpleFieldAssign//sourceId:1534153_1
            retData.setCustomField16(queryRedisBusinessOneDataRes_1.getCustomField16());//SimpleFieldAssign//sourceId:1534154_1
            retData.setCustomField17(queryRedisBusinessOneDataRes_1.getCustomField17());//SimpleFieldAssign//sourceId:1534155_1
            retData.setCustomField18(queryRedisBusinessOneDataRes_1.getCustomField18());//SimpleFieldAssign//sourceId:1534156_1
            retData.setCustomField19(queryRedisBusinessOneDataRes_1.getCustomField19());//SimpleFieldAssign//sourceId:1534157_1
            retData.setCustomField20(queryRedisBusinessOneDataRes_1.getCustomField20());//SimpleFieldAssign//sourceId:1534158_1
            retData.setCustomField21(queryRedisBusinessOneDataRes_1.getCustomField21());//SimpleFieldAssign//sourceId:1534159_1
            retData.setCustomField22(queryRedisBusinessOneDataRes_1.getCustomField22());//SimpleFieldAssign//sourceId:1534160_1
            retData.setCustomField23(queryRedisBusinessOneDataRes_1.getCustomField23());//SimpleFieldAssign//sourceId:1534161_1
            retData.setCustomField24(queryRedisBusinessOneDataRes_1.getCustomField24());//SimpleFieldAssign//sourceId:1534162_1
            retData.setCustomField25(queryRedisBusinessOneDataRes_1.getCustomField25());//SimpleFieldAssign//sourceId:1534163_1
            retData.setCustomField26(queryRedisBusinessOneDataRes_1.getCustomField26());//SimpleFieldAssign//sourceId:1534164_1
            retData.setCustomField27(queryRedisBusinessOneDataRes_1.getCustomField27());//SimpleFieldAssign//sourceId:1534165_1
            retData.setCustomField28(queryRedisBusinessOneDataRes_1.getCustomField28());//SimpleFieldAssign//sourceId:1534166_1
            retData.setCustomField29(queryRedisBusinessOneDataRes_1.getCustomField29());//SimpleFieldAssign//sourceId:1534167_1
            retData.setCustomField30(queryRedisBusinessOneDataRes_1.getCustomField30());//SimpleFieldAssign//sourceId:1534168_1
            retData.setCustomField31(queryRedisBusinessOneDataRes_1.getCustomField31());//SimpleFieldAssign//sourceId:1534169_1
            retData.setCustomField32(queryRedisBusinessOneDataRes_1.getCustomField32());//SimpleFieldAssign//sourceId:1534170_1
            retData.setCustomField33(queryRedisBusinessOneDataRes_1.getCustomField33());//SimpleFieldAssign//sourceId:1534171_1
            retData.setCustomField34(queryRedisBusinessOneDataRes_1.getCustomField34());//SimpleFieldAssign//sourceId:1534172_1
            retData.setCustomField35(queryRedisBusinessOneDataRes_1.getCustomField35());//SimpleFieldAssign//sourceId:1534173_1
            retData.setCustomField36(queryRedisBusinessOneDataRes_1.getCustomField36());//SimpleFieldAssign//sourceId:1534174_1
            retData.setCustomField37(queryRedisBusinessOneDataRes_1.getCustomField37());//SimpleFieldAssign//sourceId:1534175_1
            retData.setCustomField38(queryRedisBusinessOneDataRes_1.getCustomField38());//SimpleFieldAssign//sourceId:1534176_1
            retData.setCustomField39(queryRedisBusinessOneDataRes_1.getCustomField39());//SimpleFieldAssign//sourceId:1534177_1
            retData.setCustomField40(queryRedisBusinessOneDataRes_1.getCustomField40());//SimpleFieldAssign//sourceId:1534178_1
            retData.setCustomField41(queryRedisBusinessOneDataRes_1.getCustomField41());//SimpleFieldAssign//sourceId:1534179_1
            retData.setCustomField42(queryRedisBusinessOneDataRes_1.getCustomField42());//SimpleFieldAssign//sourceId:1534180_1
            retData.setCustomField43(queryRedisBusinessOneDataRes_1.getCustomField43());//SimpleFieldAssign//sourceId:1534181_1
            retData.setCustomField44(queryRedisBusinessOneDataRes_1.getCustomField44());//SimpleFieldAssign//sourceId:1534182_1
            retData.setCustomField45(queryRedisBusinessOneDataRes_1.getCustomField45());//SimpleFieldAssign//sourceId:1534183_1
            retData.setCustomField46(queryRedisBusinessOneDataRes_1.getCustomField46());//SimpleFieldAssign//sourceId:1534184_1
            retData.setCustomField47(queryRedisBusinessOneDataRes_1.getCustomField47());//SimpleFieldAssign//sourceId:1534185_1
            retData.setCustomField48(queryRedisBusinessOneDataRes_1.getCustomField48());//SimpleFieldAssign//sourceId:1534186_1
            retData.setCustomField49(queryRedisBusinessOneDataRes_1.getCustomField49());//SimpleFieldAssign//sourceId:1534187_1
            retData.setCustomField50(queryRedisBusinessOneDataRes_1.getCustomField50());//SimpleFieldAssign//sourceId:1534188_1
            retData.setCustomField51(queryRedisBusinessOneDataRes_1.getCustomField51());//SimpleFieldAssign//sourceId:1840390_1
            retData.setCustomField52(queryRedisBusinessOneDataRes_1.getCustomField52());//SimpleFieldAssign//sourceId:1840391_1
            retData.setCustomField53(queryRedisBusinessOneDataRes_1.getCustomField53());//SimpleFieldAssign//sourceId:1840392_1
            retData.setCustomField54(queryRedisBusinessOneDataRes_1.getCustomField54());//SimpleFieldAssign//sourceId:1840393_1
            retData.setCustomField55(queryRedisBusinessOneDataRes_1.getCustomField55());//SimpleFieldAssign//sourceId:1840394_1
            retData.setCustomField56(queryRedisBusinessOneDataRes_1.getCustomField56());//SimpleFieldAssign//sourceId:1840395_1
        }


        return retData;
    }

    /**
     * D2新增内存业务数据(公共)[8641]
     * gen by moon at 3/15/2024, 8:49:55 PM
     */
    @Trace(operationName = "D2新增内存业务数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddMemoryBusinessDataComRespDto addMemoryBusinessDataCom(AddMemoryBusinessDataComReqDto reqDto) {


        //步骤0: M2新增内存业务数据（特殊方法） - addMemoryBusinessData
        //ModelCode: addMemoryBusinessData
        AddMemoryBusinessDataRespDto addMemoryBusinessDataRes = null;
        AddMemoryBusinessDataReqDto addMemoryBusinessDataReq = new AddMemoryBusinessDataReqDto();
        if (reqDto != null) {
            addMemoryBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1610116_1
            addMemoryBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1610118_1
            addMemoryBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1610117_1
        }
        if (reqDto != null && reqDto.getMemoryBusinessDataList() != null && !CollectionUtil.isEmpty(reqDto.getMemoryBusinessDataList())) {
            addMemoryBusinessDataReq.setMemoryBusinessDataList(reqDto.getMemoryBusinessDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1610119_1
        }

        /*M2新增内存业务数据（特殊方法）[8639]   */
        Assert.isNull(addMemoryBusinessDataReq.getDataObjectBatchCode(), "D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-数据对象批次标识不能为空", false);
        Assert.isNull(addMemoryBusinessDataReq.getBusinessDataObject(), "D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(addMemoryBusinessDataReq.getIsDataList(), "D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-是否是数据集对象不能为空", false);
        addMemoryBusinessDataRes = nbInterfaceMode.addMemoryBusinessData(addMemoryBusinessDataReq);


        AddMemoryBusinessDataComRespDto retData = new AddMemoryBusinessDataComRespDto();


        return retData;
    }
///**
//   * D2查询内存业务数据详情(公共)[8642]
//   * gen by moon at 3/15/2024, 8:50:14 PM
//   */
//  @Trace(operationName = "D2查询内存业务数据详情(公共)")
//  @Tags({@Tag(key = "参数",value = "arg[0]"),
//            @Tag(key = "返回值",value = "returnedObj")})
//  @Transactional(rollbackFor=Exception.class)
//  @Override
//  public QueryMemoryBusinessDataDetailComRespDto queryMemoryBusinessDataDetailCom(QueryMemoryBusinessDataDetailComReqDto reqDto){
//
//
//      QueryMemoryBusinessDataDetailRespDto queryMemoryBusinessDataRes_1 =null;
////步骤0: M2查询内存业务数据详情（特殊方法） - queryMemoryBusinessDataDetail
//     //ModelCode: queryMemoryBusinessData
//        QueryMemoryBusinessDataDetailRespDto queryMemoryBusinessDataRes = null;
//    QueryMemoryBusinessDataDetailReqDto queryMemoryBusinessDataReq=new QueryMemoryBusinessDataDetailReqDto();
//  if(reqDto!=null){
//      queryMemoryBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1610124_1
//queryMemoryBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1610125_1
//queryMemoryBusinessDataReq.setMemoryBusinessResDataList(reqDto.getMemoryBusinessResDataList());//list-field-assign//sourceId:1610126_1
//    }
//
//    /*M2查询内存业务数据详情（特殊方法）[8640]   */
//    Assert.isNull(queryMemoryBusinessDataReq.getDataObjectBatchCode(),"D2查询内存业务数据详情(公共)-M2查询内存业务数据详情（特殊方法）-数据对象批次标识不能为空",false);
//Assert.isNull(queryMemoryBusinessDataReq.getBusinessDataObject(),"D2查询内存业务数据详情(公共)-M2查询内存业务数据详情（特殊方法）-业务数据对象不能为空",false);
//      queryMemoryBusinessDataRes = nbInterfaceMode.queryMemoryBusinessDataDetail(queryMemoryBusinessDataReq);
//
//
//      queryMemoryBusinessDataRes_1 = queryMemoryBusinessDataRes;
//
//QueryMemoryBusinessDataDetailComRespDto retData = new QueryMemoryBusinessDataDetailComRespDto();
//  if(queryMemoryBusinessDataRes_1!=null){
//      retData.setCustomField1(queryMemoryBusinessDataRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1610180_1
//retData.setCustomField2(queryMemoryBusinessDataRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1610181_1
//retData.setCustomField3(queryMemoryBusinessDataRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1610182_1
//retData.setCustomField4(queryMemoryBusinessDataRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1610183_1
//retData.setCustomField5(queryMemoryBusinessDataRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1610184_1
//retData.setCustomField6(queryMemoryBusinessDataRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1610185_1
//retData.setCustomField7(queryMemoryBusinessDataRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1610186_1
//retData.setCustomField8(queryMemoryBusinessDataRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1610187_1
//retData.setCustomField9(queryMemoryBusinessDataRes_1.getCustomField9());//SimpleFieldAssign//sourceId:1610188_1
//retData.setCustomField10(queryMemoryBusinessDataRes_1.getCustomField10());//SimpleFieldAssign//sourceId:1610189_1
//retData.setCustomField11(queryMemoryBusinessDataRes_1.getCustomField11());//SimpleFieldAssign//sourceId:1610190_1
//retData.setCustomField12(queryMemoryBusinessDataRes_1.getCustomField12());//SimpleFieldAssign//sourceId:1610191_1
//retData.setCustomField13(queryMemoryBusinessDataRes_1.getCustomField13());//SimpleFieldAssign//sourceId:1610192_1
//retData.setCustomField14(queryMemoryBusinessDataRes_1.getCustomField14());//SimpleFieldAssign//sourceId:1610193_1
//retData.setCustomField15(queryMemoryBusinessDataRes_1.getCustomField15());//SimpleFieldAssign//sourceId:1610194_1
//retData.setCustomField16(queryMemoryBusinessDataRes_1.getCustomField16());//SimpleFieldAssign//sourceId:1610195_1
//retData.setCustomField17(queryMemoryBusinessDataRes_1.getCustomField17());//SimpleFieldAssign//sourceId:1610196_1
//retData.setCustomField18(queryMemoryBusinessDataRes_1.getCustomField18());//SimpleFieldAssign//sourceId:1610197_1
//retData.setCustomField19(queryMemoryBusinessDataRes_1.getCustomField19());//SimpleFieldAssign//sourceId:1610198_1
//retData.setCustomField20(queryMemoryBusinessDataRes_1.getCustomField20());//SimpleFieldAssign//sourceId:1610199_1
//retData.setCustomField21(queryMemoryBusinessDataRes_1.getCustomField21());//SimpleFieldAssign//sourceId:1610200_1
//retData.setCustomField22(queryMemoryBusinessDataRes_1.getCustomField22());//SimpleFieldAssign//sourceId:1610201_1
//retData.setCustomField23(queryMemoryBusinessDataRes_1.getCustomField23());//SimpleFieldAssign//sourceId:1610202_1
//retData.setCustomField24(queryMemoryBusinessDataRes_1.getCustomField24());//SimpleFieldAssign//sourceId:1610203_1
//retData.setCustomField25(queryMemoryBusinessDataRes_1.getCustomField25());//SimpleFieldAssign//sourceId:1610204_1
//retData.setCustomField26(queryMemoryBusinessDataRes_1.getCustomField26());//SimpleFieldAssign//sourceId:1610205_1
//retData.setCustomField27(queryMemoryBusinessDataRes_1.getCustomField27());//SimpleFieldAssign//sourceId:1610206_1
//retData.setCustomField28(queryMemoryBusinessDataRes_1.getCustomField28());//SimpleFieldAssign//sourceId:1610207_1
//retData.setCustomField29(queryMemoryBusinessDataRes_1.getCustomField29());//SimpleFieldAssign//sourceId:1610208_1
//retData.setCustomField30(queryMemoryBusinessDataRes_1.getCustomField30());//SimpleFieldAssign//sourceId:1610209_1
//retData.setCustomField31(queryMemoryBusinessDataRes_1.getCustomField31());//SimpleFieldAssign//sourceId:1610210_1
//retData.setCustomField32(queryMemoryBusinessDataRes_1.getCustomField32());//SimpleFieldAssign//sourceId:1610211_1
//retData.setCustomField33(queryMemoryBusinessDataRes_1.getCustomField33());//SimpleFieldAssign//sourceId:1610212_1
//retData.setCustomField34(queryMemoryBusinessDataRes_1.getCustomField34());//SimpleFieldAssign//sourceId:1610213_1
//retData.setCustomField35(queryMemoryBusinessDataRes_1.getCustomField35());//SimpleFieldAssign//sourceId:1610214_1
//retData.setCustomField36(queryMemoryBusinessDataRes_1.getCustomField36());//SimpleFieldAssign//sourceId:1610215_1
//retData.setCustomField37(queryMemoryBusinessDataRes_1.getCustomField37());//SimpleFieldAssign//sourceId:1610216_1
//retData.setCustomField38(queryMemoryBusinessDataRes_1.getCustomField38());//SimpleFieldAssign//sourceId:1610217_1
//retData.setCustomField39(queryMemoryBusinessDataRes_1.getCustomField39());//SimpleFieldAssign//sourceId:1610218_1
//retData.setCustomField40(queryMemoryBusinessDataRes_1.getCustomField40());//SimpleFieldAssign//sourceId:1610219_1
//retData.setCustomField41(queryMemoryBusinessDataRes_1.getCustomField41());//SimpleFieldAssign//sourceId:1610220_1
//retData.setCustomField42(queryMemoryBusinessDataRes_1.getCustomField42());//SimpleFieldAssign//sourceId:1610221_1
//retData.setCustomField43(queryMemoryBusinessDataRes_1.getCustomField43());//SimpleFieldAssign//sourceId:1610222_1
//retData.setCustomField44(queryMemoryBusinessDataRes_1.getCustomField44());//SimpleFieldAssign//sourceId:1610223_1
//retData.setCustomField45(queryMemoryBusinessDataRes_1.getCustomField45());//SimpleFieldAssign//sourceId:1610224_1
//retData.setCustomField46(queryMemoryBusinessDataRes_1.getCustomField46());//SimpleFieldAssign//sourceId:1610225_1
//retData.setCustomField47(queryMemoryBusinessDataRes_1.getCustomField47());//SimpleFieldAssign//sourceId:1610226_1
//retData.setCustomField48(queryMemoryBusinessDataRes_1.getCustomField48());//SimpleFieldAssign//sourceId:1610227_1
//retData.setCustomField49(queryMemoryBusinessDataRes_1.getCustomField49());//SimpleFieldAssign//sourceId:1610228_1
//retData.setCustomField50(queryMemoryBusinessDataRes_1.getCustomField50());//SimpleFieldAssign//sourceId:1610229_1
//    }
//
//
//
//
//return retData;
//  }

    /**
     * D2执行数据集聚合(公共)[8667]
     * gen by moon at 3/16/2024, 11:18:41 PM
     */
    @Trace(operationName = "D2执行数据集聚合(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDatasetAggregationComRespDto implementDatasetAggregationCom(ImplementDatasetAggregationComReqDto reqDto) {


        ImplementDatasetAggregationRespDto collectionsAggregationRes_1 = null;
//步骤0: M2执行数据集聚合 - implementDatasetAggregation
        //ModelCode: collectionsAggregation
        ImplementDatasetAggregationRespDto collectionsAggregationRes = null;
        ImplementDatasetAggregationReqDto collectionsAggregationReq = new ImplementDatasetAggregationReqDto();
        if (reqDto != null && reqDto.getDataSetsListOne() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListOne())) {
            collectionsAggregationReq.setDataSetsListOne(reqDto.getDataSetsListOne().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1613823_1
        }
        if (reqDto != null && reqDto.getDataSetsListTwo() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())) {
            collectionsAggregationReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1613824_1
        }

        /*M2执行数据集聚合[8668]  入参多个数据集，按照聚合标识得到一个新的数据集 */

        collectionsAggregationRes = nbInterfaceMode.implementDatasetAggregation(collectionsAggregationReq);


        collectionsAggregationRes_1 = collectionsAggregationRes;

        ImplementDatasetAggregationComRespDto retData = new ImplementDatasetAggregationComRespDto();
        if (collectionsAggregationRes_1 != null) {
            retData.setCollectionsAggregationList(collectionsAggregationRes_1.getCollectionsAggregationList().stream().map(item -> BeanUtil.toBean(item, CollectionsAggregationDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1613833_1
        }


        return retData;
    }

    /**
     * D2执行本级过程得分权重动态分配(公共)[8687]
     * gen by moon at 5/13/2024, 12:07:25 AM
     */
    @Trace(operationName = "D2执行本级过程得分权重动态分配(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDataRedistributionComRespDto implementDataRedistributionCom(ImplementDataRedistributionComReqDto reqDto) {


        ImplementDataRedistributionRespDto dataRedistributionRes_1 = null;
//步骤0: M2执行数据重分配（特殊方法） - implementDataRedistribution
        //ModelCode: dataRedistribution
        ImplementDataRedistributionRespDto dataRedistributionRes = null;
        ImplementDataRedistributionReqDto dataRedistributionReq = new ImplementDataRedistributionReqDto();
        if (reqDto != null) {
            dataRedistributionReq.setReportScoreSubAndObjWeightChg(reqDto.getReportScoreSubAndObjWeightChg());//SimpleFieldAssign//sourceId:1617416_1
            dataRedistributionReq.setProcessReportScoreProMidWeightChg(reqDto.getProcessReportScoreProMidWeightChg());//SimpleFieldAssign//sourceId:1617377_1
            dataRedistributionReq.setProcessReportScoreMidWeightChg(reqDto.getProcessReportScoreMidWeightChg());//SimpleFieldAssign//sourceId:1617378_1
            dataRedistributionReq.setProcessReportScoreAvgWeightChg(reqDto.getProcessReportScoreAvgWeightChg());//SimpleFieldAssign//sourceId:1617380_1
            dataRedistributionReq.setWeightTotal(reqDto.getWeightTotal());//SimpleFieldAssign//sourceId:1792052_1
        }

        /*M2执行数据重分配（特殊方法）[8686]  用于过程汇报得分权重组成部分按照比例重新分配 */
        Assert.isNull(dataRedistributionReq.getReportScoreSubAndObjWeightChg(), "D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_主客观得分权重变化不能为空", false);
        Assert.isNull(dataRedistributionReq.getProcessReportScoreProMidWeightChg(), "D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_过程中期得分权重变化不能为空", false);
        Assert.isNull(dataRedistributionReq.getProcessReportScoreMidWeightChg(), "D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_中期得分权重变化不能为空", false);
        Assert.isNull(dataRedistributionReq.getProcessReportScoreAvgWeightChg(), "D2执行本级过程得分权重动态分配(公共)-M2执行数据重分配（特殊方法）-本级过程得分_最近平均分权重变化不能为空", false);
        dataRedistributionRes = nbInterfaceMode.implementDataRedistribution(dataRedistributionReq);


        dataRedistributionRes_1 = dataRedistributionRes;

        ImplementDataRedistributionComRespDto retData = new ImplementDataRedistributionComRespDto();
        if (dataRedistributionRes_1 != null) {
            retData.setReportScoreSubAndObjWeight(dataRedistributionRes_1.getReportScoreSubAndObjWeight());//SimpleFieldAssign//sourceId:1617419_1
            retData.setProcessReportScoreProMidWeight(dataRedistributionRes_1.getProcessReportScoreProMidWeight());//SimpleFieldAssign//sourceId:1617389_1
            retData.setProcessReportScoreMidWeight(dataRedistributionRes_1.getProcessReportScoreMidWeight());//SimpleFieldAssign//sourceId:1617390_1
            retData.setProcessReportScoreAvgWeight(dataRedistributionRes_1.getProcessReportScoreAvgWeight());//SimpleFieldAssign//sourceId:1617392_1
        }


        return retData;
    }

    /**
     * D2执行接收转换数值(公共)[8688]
     * gen by moon at 3/22/2024, 2:08:42 AM
     */
    @Trace(operationName = "D2执行接收转换数值(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementReceiveConversionResultValueComRespDto implementReceiveConversionResultValueCom(ImplementReceiveConversionResultValueComReqDto reqDto) {


        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_3 = null;
//virtualUsage M2接收字段  63479
        //ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes = null;
        ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq = new ImplementSmartSessionReceiveFieldInputReqDto();
        receptionServiceReq.setComFloatField1(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1618210_1_63479
        if (reqDto != null) {
            receptionServiceReq.setComFloatField(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:1618113_1_63479
            receptionServiceReq.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1618795_1_63479
        }

        /*M2接收字段[8109]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getComFloatField1(), "D2执行接收转换数值(公共)-M2接收字段-通用数值字段1（小数型）不能为空", false);
        receptionServiceRes = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq);


        if ((reqDto != null && reqDto.getComFloatField() != null)) {
            //if(D2执行接收转换数值(公共).通用数值字段（小数型） 值不等于空 )  63475

//ModelCode: receptionService
            ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_2 = null;
            ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq_1 = new ImplementSmartSessionReceiveFieldInputReqDto();
            if (reqDto != null) {
                receptionServiceReq_1.setComFloatField(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:1618203_1_63476
                receptionServiceReq_1.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1618878_1_63476
            }

            /*M2接收字段出参[8109]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getComFloatField(), "D2执行接收转换数值(公共)-M2接收字段出参-通用数值字段（小数型）不能为空", false);
            Assert.isNull(receptionServiceReq_1.getWeightValue(), "D2执行接收转换数值(公共)-M2接收字段出参-权重不能为空", false);
            receptionServiceRes_2 = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getComFloatField() == null)) {
            //elseif(D2执行接收转换数值(公共).通用数值字段（小数型） 值等于空 )  63477

//ModelCode: receptionService
            ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_4 = null;
            ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq_2 = new ImplementSmartSessionReceiveFieldInputReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setComFloatField(receptionServiceRes.getComFloatField1());//SimpleFieldAssign//sourceId:1618203_1_63478
            }
            if (reqDto != null) {
                receptionServiceReq_2.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1618878_1_63478
            }

            /*M2接收字段出参[8109]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getComFloatField(), "D2执行接收转换数值(公共)-M2接收字段出参-通用数值字段（小数型）不能为空", false);
            Assert.isNull(receptionServiceReq_2.getWeightValue(), "D2执行接收转换数值(公共)-M2接收字段出参-权重不能为空", false);
            receptionServiceRes_4 = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        }
        ImplementReceiveConversionResultValueComRespDto retData = new ImplementReceiveConversionResultValueComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setComFloatField(receptionServiceRes_3.getComFloatField());//SimpleFieldAssign//sourceId:1618213_1
            retData.setWeightValue(receptionServiceRes_3.getWeightValue());//SimpleFieldAssign//sourceId:1618880_1
        }


        return retData;
    }

    /**
     * D2执行开始与结束时间格式转换(公共)[8780]
     * gen by moon at 3/28/2024, 11:38:35 PM
     */
    @Trace(operationName = "D2执行开始与结束时间格式转换(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementStartAndEndTimeFormatComRespDto implementStartAndEndTimeFormatCom(ImplementStartAndEndTimeFormatComReqDto reqDto) {


        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes_1 = null;
//virtualUsage D2执行时间格式化(公共)  65138
        ImplementDateFormatComRespDto implementDateFormatComRespDto = null;
        ImplementDateFormatComReqDto implementDateFormatComReqDto = new ImplementDateFormatComReqDto();
        if (reqDto != null) {
            implementDateFormatComReqDto.setComTimeField(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1658346_1_65138
            implementDateFormatComReqDto.setTimeFormatMode(reqDto.getTimeFormatMode());//SimpleFieldAssign//sourceId:1658347_1_65138
        }

        /*D2执行时间格式化(公共)[8203]   */
        Assert.isNull(implementDateFormatComReqDto.getComTimeField(), "D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-通用时间字段不能为空", false);
        Assert.isNull(implementDateFormatComReqDto.getTimeFormatMode(), "D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-时间格式模式不能为空", false);
        implementDateFormatComRespDto = implementDateFormatCom(implementDateFormatComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D2执行时间格式化(公共)  65139
        ImplementDateFormatComRespDto implementDateFormatComRespDto_2 = null;
        ImplementDateFormatComReqDto implementDateFormatComReqDto_1 = new ImplementDateFormatComReqDto();
        if (reqDto != null) {
            implementDateFormatComReqDto_1.setComTimeField(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1658346_1_65139
            implementDateFormatComReqDto_1.setTimeFormatMode(reqDto.getTimeFormatMode());//SimpleFieldAssign//sourceId:1658347_1_65139
        }

        /*D2执行时间格式化(公共)[8203]   */
        Assert.isNull(implementDateFormatComReqDto_1.getComTimeField(), "D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-通用时间字段不能为空", false);
        Assert.isNull(implementDateFormatComReqDto_1.getTimeFormatMode(), "D2执行开始与结束时间格式转换(公共)-D2执行时间格式化(公共)-时间格式模式不能为空", false);
        implementDateFormatComRespDto_2 = implementDateFormatCom(implementDateFormatComReqDto_1)/*vcase invoke 同服务,同domain*/;


//virtualUsage M2接收开始与结束时间转换格式出参  65140
        //ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes = null;
        if (implementDateFormatComRespDto != null && implementDateFormatComRespDto_2 != null) {
            ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq = new ImplementSmartSessionReceiveFieldInputReqDto();
            if (implementDateFormatComRespDto != null) {
                receptionServiceReq.setCustomField1(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1658640_1_65140
            }
            if (implementDateFormatComRespDto_2 != null) {
                receptionServiceReq.setCustomField2(implementDateFormatComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1658641_1_65140
            }

            /*M2接收开始与结束时间转换格式出参[8109]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getCustomField1(), "D2执行开始与结束时间格式转换(公共)-M2接收开始与结束时间转换格式出参-自定义字段1不能为空", false);
            Assert.isNull(receptionServiceReq.getCustomField2(), "D2执行开始与结束时间格式转换(公共)-M2接收开始与结束时间转换格式出参-自定义字段2不能为空", false);
            receptionServiceRes = nbInterfaceMode.implementSmartSessionReceiveFieldInput(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        }
        ImplementStartAndEndTimeFormatComRespDto retData = new ImplementStartAndEndTimeFormatComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setCycleStartTimeName(receptionServiceRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1658644_1
            retData.setCycleEndTimeName(receptionServiceRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1658647_1
        }


        return retData;
    }

    /**
     * D2生成数据对象批次标识(公共)[9404]
     * gen by moon at 5/26/2024, 10:43:48 PM
     */
    @Trace(operationName = "D2生成数据对象批次标识(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public GenerateDataObjectBatchCodeComRespDto generateDataObjectBatchCodeCom(GenerateDataObjectBatchCodeComReqDto reqDto) {


        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        // TODO: 2024/5/22
        receptionServiceReq.setDataObjectBatchCode("EVDB");//CUSTOM_CONVENTION//sourceId:1736979_1

        /*M2生成数据对象批次标识[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDataObjectBatchCode(), "D2生成数据对象批次标识(公共)-M2生成数据对象批次标识-数据对象批次标识不能为空", false);
        receptionServiceRes = nbInterfaceMode.implementTenReceivingField(receptionServiceReq);


        receptionServiceRes_1 = receptionServiceRes;

        GenerateDataObjectBatchCodeComRespDto retData = new GenerateDataObjectBatchCodeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setDataObjectBatchCode(receptionServiceRes_1.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1736980_1
        }


        return retData;
    }

    /**
     * D2修改redis业务数据对象(公共)[9405]
     * gen by moon at 6/8/2024, 8:04:26 PM
     */
    @Trace(operationName = "D2修改redis业务数据对象(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateRedisBusinessDataComRespDto updateRedisBusinessDataCom(UpdateRedisBusinessDataComReqDto reqDto) {


        //步骤0: M2修改redis业务数据对象 - updateRedisBusinessData
        //ModelCode: updateRedisBusinessData
        UpdateRedisBusinessDataRespDto updateRedisBusinessDataRes = null;
        UpdateRedisBusinessDataReqDto updateRedisBusinessDataReq = new UpdateRedisBusinessDataReqDto();
        if (reqDto != null) {
            updateRedisBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1737028_1
            updateRedisBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1737029_1
            updateRedisBusinessDataReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819396_1
            updateRedisBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1737030_1
            updateRedisBusinessDataReq.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1830674_1
            updateRedisBusinessDataReq.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1830675_1
            updateRedisBusinessDataReq.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1830676_1
            updateRedisBusinessDataReq.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1830677_1
            updateRedisBusinessDataReq.setRefCustomField3(reqDto.getRefCustomField3());//SimpleFieldAssign//sourceId:1830678_1
            updateRedisBusinessDataReq.setRefCustomFieldValue3(reqDto.getRefCustomFieldValue3());//SimpleFieldAssign//sourceId:1830679_1
            updateRedisBusinessDataReq.setRefCustomField4(reqDto.getRefCustomField4());//SimpleFieldAssign//sourceId:1830680_1
            updateRedisBusinessDataReq.setRefCustomFieldValue4(reqDto.getRefCustomFieldValue4());//SimpleFieldAssign//sourceId:1830681_1
            updateRedisBusinessDataReq.setRefCustomField5(reqDto.getRefCustomField5());//SimpleFieldAssign//sourceId:1830682_1
            updateRedisBusinessDataReq.setRefCustomFieldValue5(reqDto.getRefCustomFieldValue5());//SimpleFieldAssign//sourceId:1830683_1
            updateRedisBusinessDataReq.setRefCustomField6(reqDto.getRefCustomField6());//SimpleFieldAssign//sourceId:1830684_1
            updateRedisBusinessDataReq.setRefCustomFieldValue6(reqDto.getRefCustomFieldValue6());//SimpleFieldAssign//sourceId:1830685_1
            updateRedisBusinessDataReq.setRefCustomField7(reqDto.getRefCustomField7());//SimpleFieldAssign//sourceId:1857067_1
            updateRedisBusinessDataReq.setRefCustomFieldValue7(reqDto.getRefCustomFieldValue7());//SimpleFieldAssign//sourceId:1857068_1
            updateRedisBusinessDataReq.setRefCustomField8(reqDto.getRefCustomField8());//SimpleFieldAssign//sourceId:1857069_1
            updateRedisBusinessDataReq.setRefCustomFieldValue8(reqDto.getRefCustomFieldValue8());//SimpleFieldAssign//sourceId:1857070_1
        }
        if (reqDto != null && reqDto.getFieldDataList() != null && !CollectionUtil.isEmpty(reqDto.getFieldDataList())) {
            updateRedisBusinessDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1737027_1
        }

        /*M2修改redis业务数据对象[9406]   */
        Assert.isNull(updateRedisBusinessDataReq.getBusinessDataObject(), "D2修改redis业务数据对象(公共)-M2修改redis业务数据对象-业务数据对象不能为空", false);
        Assert.isNull(updateRedisBusinessDataReq.getRedisDataObjectCatalogue(), "D2修改redis业务数据对象(公共)-M2修改redis业务数据对象-Redis数据对象目录不能为空", false);
        Assert.isNull(updateRedisBusinessDataReq.getIsDataList(), "D2修改redis业务数据对象(公共)-M2修改redis业务数据对象-是否是数据集对象不能为空", false);
        updateRedisBusinessDataRes = nbInterfaceMode.updateRedisBusinessData(updateRedisBusinessDataReq);


        UpdateRedisBusinessDataComRespDto retData = new UpdateRedisBusinessDataComRespDto();


        return retData;
    }

    /**
     * D2执行数据集取最新一条(公共)[9408]
     * gen by moon at 4/18/2024, 11:08:48 PM
     */
    @Trace(operationName = "D2执行数据集取最新一条(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDatasSetFetchNewLatestComRespDto implementDatasSetFetchNewLatestCom(ImplementDatasSetFetchNewLatestComReqDto reqDto) {


        ImplementDatasSetFetchNewLatestRespDto newestOfMultipleNumRes_1 = null;
//步骤0: M2执行数据集取最新一条（特殊方法） - implementDatasSetFetchNewLatest
        //ModelCode: newestOfMultipleNum
        ImplementDatasSetFetchNewLatestRespDto newestOfMultipleNumRes = null;
        ImplementDatasSetFetchNewLatestReqDto newestOfMultipleNumReq = new ImplementDatasSetFetchNewLatestReqDto();
        if (reqDto != null && reqDto.getBusinessDataSetList() != null && !CollectionUtil.isEmpty(reqDto.getBusinessDataSetList())) {
            newestOfMultipleNumReq.setBusinessDataSetList(reqDto.getBusinessDataSetList().stream().map(item -> BeanUtil.toBean(item, BusinessDataSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1737363_1
        }

        /*M2执行数据集取最新一条（特殊方法）[9409]  用于数据集中最新一条数据算法 */

        newestOfMultipleNumRes = nbInterfaceMode.implementDatasSetFetchNewLatest(newestOfMultipleNumReq);


        newestOfMultipleNumRes_1 = newestOfMultipleNumRes;

        ImplementDatasSetFetchNewLatestComRespDto retData = new ImplementDatasSetFetchNewLatestComRespDto();
        if (newestOfMultipleNumRes_1 != null) {
            retData.setCommPrimaryKey(newestOfMultipleNumRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1737365_1
        }


        return retData;
    }

    /**
     * D2执行数据集取最后一条(公共)[9408]
     * gen by moon at 4/23/2024, 3:41:05 AM
     */
    @Trace(operationName = "D2执行数据集取最后一条(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDatasSetFetchLastLatestComRespDto implementDatasSetFetchLastLatestCom(ImplementDatasSetFetchLastLatestComReqDto reqDto) {


        ImplementDatasSetFetchLastLatestRespDto newestOfMultipleNumRes_1 = null;
//步骤0: M2执行数据集取最后一条（特殊方法） - implementDatasSetFetchLastLatest
        //ModelCode: newestOfMultipleNum
        ImplementDatasSetFetchLastLatestRespDto newestOfMultipleNumRes = null;
        ImplementDatasSetFetchLastLatestReqDto newestOfMultipleNumReq = new ImplementDatasSetFetchLastLatestReqDto();
        if (reqDto != null && reqDto.getBusinessDataSetList() != null && !CollectionUtil.isEmpty(reqDto.getBusinessDataSetList())) {
            newestOfMultipleNumReq.setBusinessDataSetList(reqDto.getBusinessDataSetList().stream().map(item -> BeanUtil.toBean(item, BusinessDataSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1737363_1
        }

        /*M2执行数据集取最后一条（特殊方法）[9409]  用于数据集中最新一条数据算法 */

        newestOfMultipleNumRes = nbInterfaceMode.implementDatasSetFetchLastLatest(newestOfMultipleNumReq);


        newestOfMultipleNumRes_1 = newestOfMultipleNumRes;

        ImplementDatasSetFetchLastLatestComRespDto retData = new ImplementDatasSetFetchLastLatestComRespDto();
        if (newestOfMultipleNumRes_1 != null) {
            retData.setCommPrimaryKey(newestOfMultipleNumRes_1.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1737365_1
        }


        return retData;
    }

    /**
     * D2两数据集模糊匹配指定字段数据集结果(公共)[9545]
     * gen by moon at 5/11/2024, 11:16:20 PM
     */
    @Trace(operationName = "D2两数据集模糊匹配指定字段数据集结果(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTwoDatasVagueMateAssignDatasResultComRespDto implementTwoDatasVagueMateAssignDatasResultCom(ImplementTwoDatasVagueMateAssignDatasResultComReqDto reqDto) {


        ImplementTwoDatasVagueMateAssignDatasResultRespDto aDatasLoopVagueMateAssignBdatasResultRes_1 = null;
//步骤0: M2两数据集模糊匹配指定字段数据集结果（特殊方法） - implementTwoDatasVagueMateAssignDatasResult
        //ModelCode: aDatasLoopVagueMateAssignBdatasResult
        ImplementTwoDatasVagueMateAssignDatasResultRespDto aDatasLoopVagueMateAssignBdatasResultRes = null;
        ImplementTwoDatasVagueMateAssignDatasResultReqDto aDatasLoopVagueMateAssignBdatasResultReq = new ImplementTwoDatasVagueMateAssignDatasResultReqDto();
        if (reqDto != null) {
            aDatasLoopVagueMateAssignBdatasResultReq.setDataSetsListOne(reqDto.getDataSetsListOne());//list-field-assign//sourceId:1790000_1
        }
        if (reqDto != null && reqDto.getDataSetsListTwo() != null && !CollectionUtil.isEmpty(reqDto.getDataSetsListTwo())) {
            aDatasLoopVagueMateAssignBdatasResultReq.setDataSetsListTwo(reqDto.getDataSetsListTwo().stream().map(item -> BeanUtil.toBean(item, DataSetsListTwoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1790001_1
        }

        /*M2两数据集模糊匹配指定字段数据集结果（特殊方法）[9546]  A数据集循环发牌，模糊匹配B数据集指定字段的结果，并出参匹配的结果数据集 */

        aDatasLoopVagueMateAssignBdatasResultRes = nbInterfaceMode.implementTwoDatasVagueMateAssignDatasResult(aDatasLoopVagueMateAssignBdatasResultReq);


        aDatasLoopVagueMateAssignBdatasResultRes_1 = aDatasLoopVagueMateAssignBdatasResultRes;

        ImplementTwoDatasVagueMateAssignDatasResultComRespDto retData = new ImplementTwoDatasVagueMateAssignDatasResultComRespDto();
        if (aDatasLoopVagueMateAssignBdatasResultRes_1 != null) {
            retData.setComDatasList(aDatasLoopVagueMateAssignBdatasResultRes_1.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1790003_1
        }


        return retData;
    }

    /**
     * D2文本字段指定格式转数据集(公共)[9549]
     * gen by moon at 5/11/2024, 11:16:39 PM
     */
    @Trace(operationName = "D2文本字段指定格式转数据集(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTextFieldAssignFormatTurnDatasComRespDto implementTextFieldAssignFormatTurnDatasCom(ImplementTextFieldAssignFormatTurnDatasComReqDto reqDto) {


        ImplementTextFieldAssignFormatTurnDatasRespDto textFieldAssignFormatTurnDatasRes_1 = null;
//步骤0: M2执行文本字段指定格式转数据集（特殊方法） - implementTextFieldAssignFormatTurnDatas
        //ModelCode: textFieldAssignFormatTurnDatas
        ImplementTextFieldAssignFormatTurnDatasRespDto textFieldAssignFormatTurnDatasRes = null;
        ImplementTextFieldAssignFormatTurnDatasReqDto textFieldAssignFormatTurnDatasReq = new ImplementTextFieldAssignFormatTurnDatasReqDto();
        if (reqDto != null) {
            textFieldAssignFormatTurnDatasReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1790020_1
            textFieldAssignFormatTurnDatasReq.setSeparator(reqDto.getSeparator());//SimpleFieldAssign//sourceId:1790021_1
        }

        /*M2执行文本字段指定格式转数据集（特殊方法）[9548]  指定格式分隔符的文本字段值转数据集 */
        Assert.isNull(textFieldAssignFormatTurnDatasReq.getCustomField(), "D2文本字段指定格式转数据集(公共)-M2执行文本字段指定格式转数据集（特殊方法）-自定义字段不能为空", false);
        Assert.isNull(textFieldAssignFormatTurnDatasReq.getSeparator(), "D2文本字段指定格式转数据集(公共)-M2执行文本字段指定格式转数据集（特殊方法）-分隔符不能为空", false);
        textFieldAssignFormatTurnDatasRes = nbInterfaceMode.implementTextFieldAssignFormatTurnDatas(textFieldAssignFormatTurnDatasReq);


        textFieldAssignFormatTurnDatasRes_1 = textFieldAssignFormatTurnDatasRes;

        ImplementTextFieldAssignFormatTurnDatasComRespDto retData = new ImplementTextFieldAssignFormatTurnDatasComRespDto();
        if (textFieldAssignFormatTurnDatasRes_1 != null) {
            retData.setComDatasList(textFieldAssignFormatTurnDatasRes_1.getComDatasList());//list-field-assign//sourceId:1790025_1
        }


        return retData;
    }

    /**
     * D2输出当前树排序值(公共)[9596]
     * gen by moon at 5/17/2024, 1:45:48 AM
     */
    @Trace(operationName = "D2输出当前树排序值(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainOutPutCurrentTreeOrderNumberComRespDto obtainOutPutCurrentTreeOrderNumberCom(ObtainOutPutCurrentTreeOrderNumberComReqDto reqDto) {


        ObtainOutPutCurrentTreeOrderNumberComRespDto outPutCurrentTreeOrderNumberRes_1 = null;
//步骤0: M2输出当前树排序值(公共) - obtainOutPutCurrentTreeOrderNumberCom
        //ModelCode: outPutCurrentTreeOrderNumber
        ObtainOutPutCurrentTreeOrderNumberComRespDto outPutCurrentTreeOrderNumberRes = null;
        ObtainOutPutCurrentTreeOrderNumberComReqDto outPutCurrentTreeOrderNumberReq = new ObtainOutPutCurrentTreeOrderNumberComReqDto();
        if (reqDto != null) {
            outPutCurrentTreeOrderNumberReq.setSuperiorsTreeOrderNumbeir(reqDto.getSuperiorsTreeOrderNumbeir());//SimpleFieldAssign//sourceId:1805616_1
            outPutCurrentTreeOrderNumberReq.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:1805617_1
        }

        /*M2输出当前树排序值(公共)[9597] 通过上级树排序与当前排序，分析出当前树排序值。例如：上级树排序值1001，本级排序1，则本级树排序值为10011001 通过上级树排序与当前排序，分析出当前树排序值。例如：上级树排序值1001，本级排序1，则本级树排序值为10011001 */
        Assert.isNull(outPutCurrentTreeOrderNumberReq.getSuperiorsTreeOrderNumbeir(), "D2输出当前树排序值(公共)-M2输出当前树排序值(公共)-上级树排序不能为空", false);
        Assert.isNull(outPutCurrentTreeOrderNumberReq.getOrderNumber(), "D2输出当前树排序值(公共)-M2输出当前树排序值(公共)-排序不能为空", false);
        outPutCurrentTreeOrderNumberRes = nbInterfaceMode.obtainOutPutCurrentTreeOrderNumberCom(outPutCurrentTreeOrderNumberReq);


        outPutCurrentTreeOrderNumberRes_1 = outPutCurrentTreeOrderNumberRes;

        ObtainOutPutCurrentTreeOrderNumberComRespDto retData = new ObtainOutPutCurrentTreeOrderNumberComRespDto();
        if (outPutCurrentTreeOrderNumberRes_1 != null) {
            retData.setTreeOrderNumbeir(outPutCurrentTreeOrderNumberRes_1.getTreeOrderNumbeir());//SimpleFieldAssign//sourceId:1805621_1
        }


        return retData;
    }

    /**
     * D2执行空间配置推送内容(公共)[9606]
     * gen by moon at 5/18/2024, 7:24:23 PM
     */
    @Trace(operationName = "D2执行空间配置推送内容(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSpaceConfPushMemoryComRespDto implementSpaceConfPushMemoryCom(ImplementSpaceConfPushMemoryComReqDto reqDto) {

        //步骤0: M2执行空间配置推送内容（特殊方法） - implementSpaceConfPushMemory
        //ModelCode: publicFieldCache
        ImplementSpaceConfPushMemoryRespDto publicFieldCacheRes = null;
        ImplementSpaceConfPushMemoryReqDto publicFieldCacheReq = new ImplementSpaceConfPushMemoryReqDto();
        if (reqDto != null) {
            publicFieldCacheReq.setFileDisplayRootPath(reqDto.getFileDisplayRootPath());//SimpleFieldAssign//sourceId:1807275_1
        }

        /*M2执行空间配置推送内容（特殊方法）[9605]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
        Assert.isNull(publicFieldCacheReq.getFileDisplayRootPath(), "D2执行空间配置推送内容(公共)-M2执行空间配置推送内容（特殊方法）-文件展示根路径不能为空", false);
        publicFieldCacheRes = nbInterfaceMode.implementSpaceConfPushMemory(publicFieldCacheReq);


        ImplementSpaceConfPushMemoryComRespDto retData = new ImplementSpaceConfPushMemoryComRespDto();


        return retData;
    }

    /**
     * D2执行并发行为主题锁(悬停等待)[9699]
     * gen by moon at 6/2/2024, 10:24:41 PM
     */
    @Trace(operationName = "D2执行并发行为主题锁(悬停等待)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitCom(ImplementConcurrencyBehaviorThemeLockWaitComReqDto reqDto) {


        ImplementConcurrencyBehaviorThemeLockWaitRespDto distributedWaitLockingRes_1 = null;
        if ((reqDto != null && reqDto.getPreventConcurrentLockingUnlocking() != null && reqDto.getPreventConcurrentLockingUnlocking().equals("LOCK"))) {
            //if(D2执行并发行为主题锁(悬停等待).防并发上锁or解锁 等于 上锁)  69452

//ModelCode: distributedWaitLocking
            ImplementConcurrencyBehaviorThemeLockWaitRespDto distributedWaitLockingRes = null;
            ImplementConcurrencyBehaviorThemeLockWaitReqDto distributedWaitLockingReq = new ImplementConcurrencyBehaviorThemeLockWaitReqDto();
            if (reqDto != null) {
                distributedWaitLockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1834277_1_69454
                distributedWaitLockingReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1834285_1_69454
                distributedWaitLockingReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1834286_1_69454
                distributedWaitLockingReq.setWaitingTime(reqDto.getWaitingTime());//SimpleFieldAssign//sourceId:1834278_1_69454
                distributedWaitLockingReq.setWaitTimeUnitType(reqDto.getWaitTimeUnitType());//SimpleFieldAssign//sourceId:1834279_1_69454
                distributedWaitLockingReq.setDuration(reqDto.getDuration());//SimpleFieldAssign//sourceId:1834280_1_69454
                distributedWaitLockingReq.setTimeUnitType(reqDto.getTimeUnitType());//SimpleFieldAssign//sourceId:1834281_1_69454
            }

            /*M2执行并发行为主题锁(悬停等待)[9700]  用于新增分布式锁，支持有上锁等待并执行 */
            Assert.isNull(distributedWaitLockingReq.getRedisDataObjectCatalogue(), "D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-Redis数据对象目录不能为空", false);
            Assert.isNull(distributedWaitLockingReq.getBusinessDataObject(), "D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-业务数据对象不能为空", false);
            Assert.isNull(distributedWaitLockingReq.getDataObjectBatchCode(), "D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-数据对象批次标识不能为空", false);
            Assert.isNull(distributedWaitLockingReq.getWaitingTime(), "D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-等待时长不能为空", false);
            Assert.isNull(distributedWaitLockingReq.getWaitTimeUnitType(), "D2执行并发行为主题锁(悬停等待)-M2执行并发行为主题锁(悬停等待)-等待时间单位类型不能为空", false);
            distributedWaitLockingRes = nbInterfaceMode.implementConcurrencyBehaviorThemeLockWait(distributedWaitLockingReq);


            distributedWaitLockingRes_1 = distributedWaitLockingRes;
        } else if ((reqDto != null && reqDto.getPreventConcurrentLockingUnlocking() != null && reqDto.getPreventConcurrentLockingUnlocking().equals("UNLOCK"))) {
            //elseif(D2执行并发行为主题锁(悬停等待).防并发上锁or解锁 等于 解锁)  69453

//ModelCode: distributedUnlocking
            ImplementUnlockingConcBhvThemesLockComRespDto distributedUnlockingRes = null;
            ImplementUnlockingConcBhvThemesLockComReqDto distributedUnlockingReq = new ImplementUnlockingConcBhvThemesLockComReqDto();
            if (reqDto != null) {
                distributedUnlockingReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1833949_1_69455
                distributedUnlockingReq.setBehaviorThemeLockCode(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1833944_1_69455
                distributedUnlockingReq.setCommPrimaryKey(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1833945_1_69455
            }

            /*M2-执行解锁并发行为主题锁（特殊方法）[8393]   */
            Assert.isNull(distributedUnlockingReq.getRedisDataObjectCatalogue(), "D2执行并发行为主题锁(悬停等待)-M2-执行解锁并发行为主题锁（特殊方法）-Redis数据对象目录不能为空", false);
            Assert.isNull(distributedUnlockingReq.getBehaviorThemeLockCode(), "D2执行并发行为主题锁(悬停等待)-M2-执行解锁并发行为主题锁（特殊方法）-行为主题锁业务数据对象不能为空", false);
            Assert.isNull(distributedUnlockingReq.getCommPrimaryKey(), "D2执行并发行为主题锁(悬停等待)-M2-执行解锁并发行为主题锁（特殊方法）-通用主键ID不能为空", false);
            distributedUnlockingRes = nbInterfaceMode.implementUnlockingConcBhvThemesLockCom(distributedUnlockingReq);


        }
        ImplementConcurrencyBehaviorThemeLockWaitComRespDto retData = new ImplementConcurrencyBehaviorThemeLockWaitComRespDto();
        if (distributedWaitLockingRes_1 != null) {
            retData.setPreventConcurrentLockingSituations(distributedWaitLockingRes_1.getPreventConcurrentLockingSituations());//SimpleFieldAssign//sourceId:1846064_1
        }


        return retData;
    }

    /**
     * D2新增内存业务数据(公共)[9750]
     * gen by moon at 6/6/2024, 3:48:18 PM
     */
    @Trace(operationName = "D2新增内存业务数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddMemory2BusinessDataComRespDto addMemory2BusinessDataCom(AddMemory2BusinessDataComReqDto reqDto) {


        //步骤0: M2新增内存业务数据（特殊方法） - addMemory2BusinessData
        //ModelCode: addMemoryBusinessData
        AddMemory2BusinessDataRespDto addMemoryBusinessDataRes = null;
        AddMemory2BusinessDataReqDto addMemoryBusinessDataReq = new AddMemory2BusinessDataReqDto();
        if (reqDto != null) {
            addMemoryBusinessDataReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1852138_1
            addMemoryBusinessDataReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1852139_1
            addMemoryBusinessDataReq.setIsDataList(reqDto.getIsDataList());//SimpleFieldAssign//sourceId:1852140_1
        }
        if (reqDto != null && reqDto.getMemoryBusinessDataList() != null && !CollectionUtil.isEmpty(reqDto.getMemoryBusinessDataList())) {
            addMemoryBusinessDataReq.setMemoryBusinessDataList(reqDto.getMemoryBusinessDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1852141_1
        }

        /*M2新增内存业务数据（特殊方法）[9749]   */
        Assert.isNull(addMemoryBusinessDataReq.getDataObjectBatchCode(), "D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-数据对象批次标识不能为空", false);
        Assert.isNull(addMemoryBusinessDataReq.getBusinessDataObject(), "D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(addMemoryBusinessDataReq.getIsDataList(), "D2新增内存业务数据(公共)-M2新增内存业务数据（特殊方法）-是否是数据集对象不能为空", false);
        addMemoryBusinessDataRes = nbInterfaceMode.addMemory2BusinessData(addMemoryBusinessDataReq);


        AddMemory2BusinessDataComRespDto retData = new AddMemory2BusinessDataComRespDto();


        return retData;
    }

    /**
     * D2执行业务组件公共字段推送内存(公共)[9753]
     * gen by moon at 6/6/2024, 3:49:00 PM
     */
    @Trace(operationName = "D2执行业务组件公共字段推送内存(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementBizModuleAccessParameterFieldComRespDto implementBizModuleAccessParameterFieldCom(ImplementBizModuleAccessParameterFieldComReqDto reqDto) {


        //步骤0: M2执行业务组件公共字段推送内存（特殊方法） - implementBizModuleAccessParameterField
        //ModelCode: publicFieldCache
        ImplementBizModuleAccessParameterFieldRespDto publicFieldCacheRes = null;
        ImplementBizModuleAccessParameterFieldReqDto publicFieldCacheReq = new ImplementBizModuleAccessParameterFieldReqDto();
        if (reqDto != null) {
            publicFieldCacheReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1852637_1
            publicFieldCacheReq.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1852647_1
            publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1852639_1
            publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1852638_1
        }

        /*M2执行业务组件公共字段推送内存（特殊方法）[4834]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
        Assert.isNull(publicFieldCacheReq.getCreateInductionId(), "D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-创建人就职记录ID不能为空", false);
        Assert.isNull(publicFieldCacheReq.getOperationInductionId(), "D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-操作人就职记录ID不能为空", false);
        Assert.isNull(publicFieldCacheReq.getSpaceId(), "D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-创建于空间ID不能为空", false);
        Assert.isNull(publicFieldCacheReq.getAppId(), "D2执行业务组件公共字段推送内存(公共)-M2执行业务组件公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空", false);
        publicFieldCacheRes = nbInterfaceMode.implementBizModuleAccessParameterField(publicFieldCacheReq);


        ImplementBizModuleAccessParameterFieldComRespDto retData = new ImplementBizModuleAccessParameterFieldComRespDto();


        return retData;
    }

    /**
     * D2执行时间格式转换(公共)[9757]
     * gen by moon at 6/8/2024, 3:19:05 AM
     */
    @Trace(operationName = "D2执行时间格式转换(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTimeFormatConversionComRespDto implementTimeFormatConversionCom(ImplementTimeFormatConversionComReqDto reqDto) {


        ImplementTimeFormatConversionRespDto timeFormatConversionRes_1 = null;
//步骤0: M2执行时间格式转换（特殊字段） - implementTimeFormatConversion
        //ModelCode: timeFormatConversion
        ImplementTimeFormatConversionRespDto timeFormatConversionRes = null;
        ImplementTimeFormatConversionReqDto timeFormatConversionReq = new ImplementTimeFormatConversionReqDto();
        if (reqDto != null) {
            timeFormatConversionReq.setComTxtField(reqDto.getComTxtField());//SimpleFieldAssign//sourceId:1855385_1
        }

        /*M2执行时间格式转换（特殊字段）[9756]  将非标时间格式转换为标准时间格式YYYY-MM-DD 00:00:00 */
        Assert.isNull(timeFormatConversionReq.getComTxtField(), "D2执行时间格式转换(公共)-M2执行时间格式转换（特殊字段）-通用文本字段不能为空", false);
        timeFormatConversionRes = nbInterfaceMode.implementTimeFormatConversion(timeFormatConversionReq);


        timeFormatConversionRes_1 = timeFormatConversionRes;

        ImplementTimeFormatConversionComRespDto retData = new ImplementTimeFormatConversionComRespDto();
        if (timeFormatConversionRes_1 != null) {
            retData.setComTxtField(timeFormatConversionRes_1.getComTxtField());//SimpleFieldAssign//sourceId:1855388_1
        }


        return retData;
    }

    /**
     * D2执行数据集取一条（含时间）(公共)[9774]
     * gen by moon at 6/9/2024, 3:59:20 PM
     */
    @Trace(operationName = "D2执行数据集取一条（含时间）(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDatasFetchLastLatestWithTimeComRespDto implementDatasFetchLastLatestWithTimeCom(ImplementDatasFetchLastLatestWithTimeComReqDto reqDto) {


        ImplementDatasFetchLastLatestWithTimeRespDto dataSetFetchLastRes_1 = null;
//步骤0: M2执行数据集取最后一条（含时间）（特殊方法） - implementDatasFetchLastLatestWithTime
        //ModelCode: dataSetFetchLast
        ImplementDatasFetchLastLatestWithTimeRespDto dataSetFetchLastRes = null;
        ImplementDatasFetchLastLatestWithTimeReqDto dataSetFetchLastReq = new ImplementDatasFetchLastLatestWithTimeReqDto();
        if (reqDto != null && reqDto.getComDatasList() != null && !CollectionUtil.isEmpty(reqDto.getComDatasList())) {
            dataSetFetchLastReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1858588_1
        }
        if (reqDto != null) {
            dataSetFetchLastReq.setOrderSizeType(reqDto.getOrderSizeType());//SimpleFieldAssign//sourceId:1860265_1
        }

        /*M2执行数据集取最一条（含时间）（特殊方法）[9773]  从数据集多条记录中取排序在数据集中最后一条记录并出参 */

        dataSetFetchLastRes = nbInterfaceMode.implementDatasFetchLastLatestWithTime(dataSetFetchLastReq);


        dataSetFetchLastRes_1 = dataSetFetchLastRes;

        ImplementDatasFetchLastLatestWithTimeComRespDto retData = new ImplementDatasFetchLastLatestWithTimeComRespDto();
        if (dataSetFetchLastRes_1 != null) {
            retData.setCustomField1(dataSetFetchLastRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1858600_1
            retData.setCustomField2(dataSetFetchLastRes_1.getCustomField2());//SimpleFieldAssign//sourceId:1858601_1
            retData.setCustomField3(dataSetFetchLastRes_1.getCustomField3());//SimpleFieldAssign//sourceId:1858602_1
            retData.setCustomField4(dataSetFetchLastRes_1.getCustomField4());//SimpleFieldAssign//sourceId:1858603_1
            retData.setCustomField5(dataSetFetchLastRes_1.getCustomField5());//SimpleFieldAssign//sourceId:1858604_1
            retData.setCustomField6(dataSetFetchLastRes_1.getCustomField6());//SimpleFieldAssign//sourceId:1858605_1
            retData.setCustomField7(dataSetFetchLastRes_1.getCustomField7());//SimpleFieldAssign//sourceId:1858606_1
            retData.setCustomField8(dataSetFetchLastRes_1.getCustomField8());//SimpleFieldAssign//sourceId:1858607_1
            retData.setComTimeField1(dataSetFetchLastRes_1.getComTimeField1());//SimpleFieldAssign//sourceId:1860266_1
            retData.setComTimeField2(dataSetFetchLastRes_1.getComTimeField2());//SimpleFieldAssign//sourceId:1860267_1
        }


        return retData;
    }

    /**
     * D2执行单条相对地址转全路径(公共)[9811]
     * gen by moon at 6/15/2024, 4:49:14 PM
     */
    @Trace(operationName = "D2执行单条相对地址转全路径(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSingleRelativePathConvertToFullPathComRespDto implementSingleRelativePathConvertToFullPathCom(ImplementSingleRelativePathConvertToFullPathComReqDto reqDto) {


        ImplementSingleRelativePathConvertToFullPathRespDto FILE_ADDRESS_ALL_PATHRes_1 = null;
//步骤0: M2执行单条相对地址转全路径（特殊方法） - implementSingleRelativePathConvertToFullPath
        //ModelCode: FILE_ADDRESS_ALL_PATH
        ImplementSingleRelativePathConvertToFullPathRespDto FILE_ADDRESS_ALL_PATHRes = null;
        ImplementSingleRelativePathConvertToFullPathReqDto FILE_ADDRESS_ALL_PATHReq = new ImplementSingleRelativePathConvertToFullPathReqDto();
        if (reqDto != null) {
            FILE_ADDRESS_ALL_PATHReq.setRelativePath(reqDto.getRelativePath());//SimpleFieldAssign//sourceId:1866983_1
        }

        /*M2执行单条相对地址转全路径（特殊方法）[9810]   */
        Assert.isNull(FILE_ADDRESS_ALL_PATHReq.getRelativePath(), "D2执行单条相对地址转全路径(公共)-M2执行单条相对地址转全路径（特殊方法）-相对地址不能为空", false);
        FILE_ADDRESS_ALL_PATHRes = nbInterfaceMode.implementSingleRelativePathConvertToFullPath(FILE_ADDRESS_ALL_PATHReq);


        FILE_ADDRESS_ALL_PATHRes_1 = FILE_ADDRESS_ALL_PATHRes;

        ImplementSingleRelativePathConvertToFullPathComRespDto retData = new ImplementSingleRelativePathConvertToFullPathComRespDto();
        if (FILE_ADDRESS_ALL_PATHRes_1 != null) {
            retData.setFullPath(FILE_ADDRESS_ALL_PATHRes_1.getFullPath());//SimpleFieldAssign//sourceId:1866985_1
        }


        return retData;
    }

    /**
     * D2查询内存业务数据列表(公共)[10423]
     * gen by moon at 12/6/2024, 10:03:21 PM
     */
    @Trace(operationName = "D2查询内存业务数据列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryMemoryBusinessDataListComRespDto queryMemoryBusinessDataListCom(QueryMemoryBusinessDataListComReqDto reqDto) {


        QueryMemoryBusinessDataListRespDto queryMemoryBusinessDatasRes_1 = null;
//步骤0: M2查询内存业务数据列表（特殊方法） - queryMemoryBusinessDataList
        //ModelCode: queryMemoryBusinessDatas
        QueryMemoryBusinessDataListRespDto queryMemoryBusinessDatasRes = null;
        QueryMemoryBusinessDataListReqDto queryMemoryBusinessDatasReq = new QueryMemoryBusinessDataListReqDto();
        if (reqDto != null) {
            queryMemoryBusinessDatasReq.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:2033876_1
            queryMemoryBusinessDatasReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:2033877_1
        }
        if (reqDto != null && reqDto.getMemoryBusinessResDataList() != null && !CollectionUtil.isEmpty(reqDto.getMemoryBusinessResDataList())) {
            queryMemoryBusinessDatasReq.setMemoryBusinessResDataList(reqDto.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2033878_1
        }

        /*M2查询内存业务数据列表（特殊方法）[10422]   */
        Assert.isNull(queryMemoryBusinessDatasReq.getBusinessDataObject(), "D2查询内存业务数据列表(公共)-M2查询内存业务数据列表（特殊方法）-业务数据对象不能为空", false);
        Assert.isNull(queryMemoryBusinessDatasReq.getDataObjectBatchCode(), "D2查询内存业务数据列表(公共)-M2查询内存业务数据列表（特殊方法）-数据对象批次标识不能为空", false);
        queryMemoryBusinessDatasRes = nbInterfaceMode.queryMemoryBusinessDataList(queryMemoryBusinessDatasReq);


        queryMemoryBusinessDatasRes_1 = queryMemoryBusinessDatasRes;

        QueryMemoryBusinessDataListComRespDto retData = new QueryMemoryBusinessDataListComRespDto();
        if (queryMemoryBusinessDatasRes_1 != null) {
            retData.setMemoryBusinessResDataList(queryMemoryBusinessDatasRes_1.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2033883_1
        }


        return retData;
    }

    /**
     * D2查询内存业务数据列表(业务原子)[10425]
     * gen by moon at 12/6/2024, 10:03:54 PM
     */
    @Trace(operationName = "D2查询内存业务数据列表(业务原子)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListCom(QueryMemorysBusinessDataListComReqDto reqDto) {


        QueryMemoryBusinessDataListComRespDto queryMemoryBusinessDataListComRespDto_1 = null;
//步骤0: D2-分析单字段批量转数据集(公共) - analysisFieldBatchDataCom
        AnalysisFieldBatchDataComRespDto analysisFieldBatchDataComRespDto = null;
        AnalysisFieldBatchDataComReqDto analysisFieldBatchDataComReqDto = new AnalysisFieldBatchDataComReqDto();
        analysisFieldBatchDataComReqDto.setCustomFieldValue1("customField1");//CUSTOM_CONVENTION//sourceId:2034010_1
        analysisFieldBatchDataComReqDto.setCustomFieldValue2("customField2");//CUSTOM_CONVENTION//sourceId:2034012_1
        analysisFieldBatchDataComReqDto.setCustomFieldValue3("customField3");//CUSTOM_CONVENTION//sourceId:2034014_1
        analysisFieldBatchDataComReqDto.setCustomFieldValue4("customField4");//CUSTOM_CONVENTION//sourceId:2034016_1
        analysisFieldBatchDataComReqDto.setCustomFieldValue5("customField5");//CUSTOM_CONVENTION//sourceId:2034018_1
        analysisFieldBatchDataComReqDto.setCustomFieldValue6("customField6");//CUSTOM_CONVENTION//sourceId:2034020_1
        analysisFieldBatchDataComReqDto.setCustomFieldValue7("customField7");//CUSTOM_CONVENTION//sourceId:2034022_1
        analysisFieldBatchDataComReqDto.setCustomFieldValue8("customField8");//CUSTOM_CONVENTION//sourceId:2034024_1
        if (reqDto != null) {
            analysisFieldBatchDataComReqDto.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2034009_1
            analysisFieldBatchDataComReqDto.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:2034011_1
            analysisFieldBatchDataComReqDto.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:2034013_1
            analysisFieldBatchDataComReqDto.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:2034015_1
            analysisFieldBatchDataComReqDto.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:2034017_1
            analysisFieldBatchDataComReqDto.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:2034019_1
            analysisFieldBatchDataComReqDto.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:2034021_1
            analysisFieldBatchDataComReqDto.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:2034023_1
        }

        /*D2-分析单字段批量转数据集(公共)[8405]   */
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue1(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值1不能为空", false);
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue2(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值2不能为空", false);
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue3(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值3不能为空", false);
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue4(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值4不能为空", false);
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue5(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值5不能为空", false);
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue6(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值6不能为空", false);
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue7(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值7不能为空", false);
        Assert.isNull(analysisFieldBatchDataComReqDto.getCustomFieldValue8(), "D2查询内存业务数据列表(业务原子)-D2-分析单字段批量转数据集(公共)-自定义字段值8不能为空", false);
        analysisFieldBatchDataComRespDto = analysisFieldBatchDataCom(analysisFieldBatchDataComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤1: D2查询内存业务数据列表(公共) - queryMemoryBusinessDataListCom
        QueryMemoryBusinessDataListComRespDto queryMemoryBusinessDataListComRespDto = null;
        if (analysisFieldBatchDataComRespDto != null) {
            QueryMemoryBusinessDataListComReqDto queryMemoryBusinessDataListComReqDto = new QueryMemoryBusinessDataListComReqDto();
            if (reqDto != null) {
                queryMemoryBusinessDataListComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:2033885_1
                queryMemoryBusinessDataListComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:2033886_1
            }
            if (analysisFieldBatchDataComRespDto != null && analysisFieldBatchDataComRespDto.getFieldBatchDataList() != null && !CollectionUtil.isEmpty(analysisFieldBatchDataComRespDto.getFieldBatchDataList())) {
                queryMemoryBusinessDataListComReqDto.setMemoryBusinessResDataList(analysisFieldBatchDataComRespDto.getFieldBatchDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2033884_1
            }

            /*D2查询内存业务数据列表(公共)[10423]   */
            Assert.isNull(queryMemoryBusinessDataListComReqDto.getBusinessDataObject(), "D2查询内存业务数据列表(业务原子)-D2查询内存业务数据列表(公共)-业务数据对象不能为空", false);
            Assert.isNull(queryMemoryBusinessDataListComReqDto.getDataObjectBatchCode(), "D2查询内存业务数据列表(业务原子)-D2查询内存业务数据列表(公共)-数据对象批次标识不能为空", false);
            queryMemoryBusinessDataListComRespDto = queryMemoryBusinessDataListCom(queryMemoryBusinessDataListComReqDto)/*vcase invoke 同服务,同domain*/;


            queryMemoryBusinessDataListComRespDto_1 = queryMemoryBusinessDataListComRespDto;
        }

        QueryMemorysBusinessDataListComRespDto retData = new QueryMemorysBusinessDataListComRespDto();
        if (queryMemoryBusinessDataListComRespDto_1 != null) {
            retData.setMemoryBusinessResDataList(queryMemoryBusinessDataListComRespDto_1.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, MemoryBusinessResDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2034035_1
        }


        return retData;
    }

    /**
     * D2执行多字段转json字符串(公共)[10436]
     * gen by moon at 12/8/2024, 3:23:01 AM
     */
    @Trace(operationName = "D2执行多字段转json字符串(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMutFeldToJsonStringComRespDto implementMutFeldToJsonStringCom(ImplementMutFeldToJsonStringComReqDto reqDto) {


        ImplementMutFeldToJsonStringRespDto mutiFieldToJsonStringRes_1 = null;
//步骤0: M2执行多字段转json字符串（特殊方法） - implementMutFeldToJsonString
        //ModelCode: mutiFieldToJsonString
        ImplementMutFeldToJsonStringRespDto mutiFieldToJsonStringRes = null;
        ImplementMutFeldToJsonStringReqDto mutiFieldToJsonStringReq = new ImplementMutFeldToJsonStringReqDto();
        if (reqDto != null) {
            mutiFieldToJsonStringReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2034676_1
            mutiFieldToJsonStringReq.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:2034681_1
            mutiFieldToJsonStringReq.setCustomField2(reqDto.getCustomField2());//SimpleFieldAssign//sourceId:2034677_1
            mutiFieldToJsonStringReq.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:2034679_1
            mutiFieldToJsonStringReq.setCustomField3(reqDto.getCustomField3());//SimpleFieldAssign//sourceId:2034678_1
            mutiFieldToJsonStringReq.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:2034680_1
            mutiFieldToJsonStringReq.setCustomField4(reqDto.getCustomField4());//SimpleFieldAssign//sourceId:2034704_1
            mutiFieldToJsonStringReq.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:2034705_1
            mutiFieldToJsonStringReq.setCustomField5(reqDto.getCustomField5());//SimpleFieldAssign//sourceId:2034706_1
            mutiFieldToJsonStringReq.setCustomFieldValue5(reqDto.getCustomFieldValue5());//SimpleFieldAssign//sourceId:2034707_1
            mutiFieldToJsonStringReq.setCustomField6(reqDto.getCustomField6());//SimpleFieldAssign//sourceId:2034708_1
            mutiFieldToJsonStringReq.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:2034709_1
            mutiFieldToJsonStringReq.setCustomField7(reqDto.getCustomField7());//SimpleFieldAssign//sourceId:2034710_1
            mutiFieldToJsonStringReq.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:2034711_1
            mutiFieldToJsonStringReq.setCustomField8(reqDto.getCustomField8());//SimpleFieldAssign//sourceId:2034712_1
            mutiFieldToJsonStringReq.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:2034713_1
            mutiFieldToJsonStringReq.setCustomField9(reqDto.getCustomField9());//SimpleFieldAssign//sourceId:2034714_1
            mutiFieldToJsonStringReq.setCustomFieldValue9(reqDto.getCustomFieldValue9());//SimpleFieldAssign//sourceId:2034715_1
            mutiFieldToJsonStringReq.setCustomField10(reqDto.getCustomField10());//SimpleFieldAssign//sourceId:2034716_1
            mutiFieldToJsonStringReq.setCustomFieldValue10(reqDto.getCustomFieldValue10());//SimpleFieldAssign//sourceId:2034717_1
        }

        /*M2执行多字段转json字符串（特殊方法）[10435]   */

        mutiFieldToJsonStringRes = nbInterfaceMode.implementMutFeldToJsonString(mutiFieldToJsonStringReq);


        mutiFieldToJsonStringRes_1 = mutiFieldToJsonStringRes;

        ImplementMutFeldToJsonStringComRespDto retData = new ImplementMutFeldToJsonStringComRespDto();
        if (mutiFieldToJsonStringRes_1 != null) {
            retData.setCustomText(mutiFieldToJsonStringRes_1.getCustomText());//SimpleFieldAssign//sourceId:2034689_1
        }


        return retData;
    }

    /**
     * D2新增节点(公共)[10465]
     * gen by moon at 12/18/2024, 6:45:00 PM
     */
    @Trace(operationName = "D2新增节点(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddNodeGraphDatabaseComRespDto addNodeGraphDatabaseCom(AddNodeGraphDatabaseComReqDto reqDto) {


        AddNodeGraphDatabaseRespDto addNodeGraphDatabaseRes_1 = null;
//步骤0: M2新增节点（特殊方法） - addNodeGraphDatabase
        //ModelCode: addNodeGraphDatabase
        AddNodeGraphDatabaseRespDto addNodeGraphDatabaseRes = null;
        AddNodeGraphDatabaseReqDto addNodeGraphDatabaseReq = new AddNodeGraphDatabaseReqDto();
        if (reqDto != null) {
            addNodeGraphDatabaseReq.setNodeType(reqDto.getNodeType());//SimpleFieldAssign//sourceId:2037214_1
        }
        if (reqDto != null && reqDto.getNodeAttributeGraphDatabaseList() != null && !CollectionUtil.isEmpty(reqDto.getNodeAttributeGraphDatabaseList())) {
            addNodeGraphDatabaseReq.setNodeAttributeGraphDatabaseList(reqDto.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037215_1
        }

        /*M2新增节点（特殊方法）[10455]   */
        Assert.isNull(addNodeGraphDatabaseReq.getNodeType(), "D2新增节点(公共)-M2新增节点（特殊方法）-节点类型不能为空", false);
        addNodeGraphDatabaseRes = nbInterfaceMode.addNodeGraphDatabase(addNodeGraphDatabaseReq);


        addNodeGraphDatabaseRes_1 = addNodeGraphDatabaseRes;

        AddNodeGraphDatabaseComRespDto retData = new AddNodeGraphDatabaseComRespDto();
        if (addNodeGraphDatabaseRes_1 != null) {
            retData.setNodeId(addNodeGraphDatabaseRes_1.getNodeId());//SimpleFieldAssign//sourceId:2037219_1
        }


        return retData;
    }

    /**
     * D2删除节点(公共)[10466]
     * gen by moon at 12/18/2024, 6:45:20 PM
     */
    @Trace(operationName = "D2删除节点(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteNodeGraphDatabaseComRespDto deleteNodeGraphDatabaseCom(DeleteNodeGraphDatabaseComReqDto reqDto) {


        //步骤0: M2删除节点（特殊方法） - deleteNodeGraphDatabase
        //ModelCode: deleteNodeGraphDatabase
        DeleteNodeGraphDatabaseRespDto deleteNodeGraphDatabaseRes = null;
        DeleteNodeGraphDatabaseReqDto deleteNodeGraphDatabaseReq = new DeleteNodeGraphDatabaseReqDto();
        if (reqDto != null) {
            deleteNodeGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037221_1
        }

        /*M2删除节点（特殊方法）[10456]   */
        Assert.isNull(deleteNodeGraphDatabaseReq.getNodeId(), "D2删除节点(公共)-M2删除节点（特殊方法）-节点ID（唯一标识）不能为空", false);
        deleteNodeGraphDatabaseRes = nbInterfaceMode.deleteNodeGraphDatabase(deleteNodeGraphDatabaseReq);


        DeleteNodeGraphDatabaseComRespDto retData = new DeleteNodeGraphDatabaseComRespDto();


        return retData;
    }

    /**
     * D2查询节点详情(公共)[10467]
     * gen by moon at 12/18/2024, 6:45:40 PM
     */
    @Trace(operationName = "D2查询节点详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryNodeGraphDatabaseDetailComRespDto queryNodeGraphDatabaseDetailCom(QueryNodeGraphDatabaseDetailComReqDto reqDto) {


        QueryNodeGraphDatabaseDetailRespDto queryNodeDetailGraphDatabaseRes_1 = null;
//步骤0: M2查询节点详情（特殊方法） - queryNodeGraphDatabaseDetail
        //ModelCode: queryNodeDetailGraphDatabase
        QueryNodeGraphDatabaseDetailRespDto queryNodeDetailGraphDatabaseRes = null;
        QueryNodeGraphDatabaseDetailReqDto queryNodeDetailGraphDatabaseReq = new QueryNodeGraphDatabaseDetailReqDto();
        if (reqDto != null) {
            queryNodeDetailGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037228_1
            queryNodeDetailGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037229_1
        }

        /*M2查询节点详情（特殊方法）[10457]   */
        Assert.isNull(queryNodeDetailGraphDatabaseReq.getNodeId(), "D2查询节点详情(公共)-M2查询节点详情（特殊方法）-节点ID（唯一标识）不能为空", false);
        queryNodeDetailGraphDatabaseRes = nbInterfaceMode.queryNodeGraphDatabaseDetail(queryNodeDetailGraphDatabaseReq);


        queryNodeDetailGraphDatabaseRes_1 = queryNodeDetailGraphDatabaseRes;

        QueryNodeGraphDatabaseDetailComRespDto retData = new QueryNodeGraphDatabaseDetailComRespDto();
        if (queryNodeDetailGraphDatabaseRes_1 != null) {
            retData.setNodeId(queryNodeDetailGraphDatabaseRes_1.getNodeId());//SimpleFieldAssign//sourceId:2037235_1
            retData.setNodeType(queryNodeDetailGraphDatabaseRes_1.getNodeType());//SimpleFieldAssign//sourceId:2037236_1
            retData.setNodeAttributeGraphDatabaseList(queryNodeDetailGraphDatabaseRes_1.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037237_1
        }


        return retData;
    }

    /**
     * D2查询节点列表(公共)[10468]
     * gen by moon at 12/18/2024, 6:46:13 PM
     */
    @Trace(operationName = "D2查询节点列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryNodeGraphDatabaseListComRespDto queryNodeGraphDatabaseListCom(QueryNodeGraphDatabaseListComReqDto reqDto) {


        QueryNodeGraphDatabaseListRespDto queryNodeListGraphDatabaseRes_1 = null;
//步骤0: M2查询节点列表（特殊方法） - queryNodeGraphDatabaseList
        //ModelCode: queryNodeListGraphDatabase
        QueryNodeGraphDatabaseListRespDto queryNodeListGraphDatabaseRes = null;
        QueryNodeGraphDatabaseListReqDto queryNodeListGraphDatabaseReq = new QueryNodeGraphDatabaseListReqDto();
        if (reqDto != null) {
            queryNodeListGraphDatabaseReq.setRelationType(reqDto.getRelationType());//SimpleFieldAssign//sourceId:2037244_1
            queryNodeListGraphDatabaseReq.setRelationDirection(reqDto.getRelationDirection());//SimpleFieldAssign//sourceId:2037245_1
            queryNodeListGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037247_1
        }
        if (reqDto != null && reqDto.getNodeAttributeGraphDatabaseList() != null && !CollectionUtil.isEmpty(reqDto.getNodeAttributeGraphDatabaseList())) {
            queryNodeListGraphDatabaseReq.setNodeAttributeGraphDatabaseList(reqDto.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037246_1
        }

        /*M2查询节点列表（特殊方法）[10458]   */

        queryNodeListGraphDatabaseRes = nbInterfaceMode.queryNodeGraphDatabaseList(queryNodeListGraphDatabaseReq);


        queryNodeListGraphDatabaseRes_1 = queryNodeListGraphDatabaseRes;

        QueryNodeGraphDatabaseListComRespDto retData = new QueryNodeGraphDatabaseListComRespDto();
        if (queryNodeListGraphDatabaseRes_1 != null) {
            retData.setNodeGraphDatabaseList(queryNodeListGraphDatabaseRes_1.getNodeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037254_1
            retData.setNodeAttributeGraphDatabaseList(queryNodeListGraphDatabaseRes_1.getNodeAttributeGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeAttributeGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037255_1
        }

        // TODO: 2024/12/23 手写代码
        for (NodeGraphDatabaseDto one : retData.getNodeGraphDatabaseList()) {
            TreeNode elm = new TreeNode();
            elm.setChildrenList(new ArrayList<>());
            elm.setSelf(one);
            for (NodeAttributeGraphDatabaseDto subOne : retData.getNodeAttributeGraphDatabaseList()) {
                if (subOne.getNodeId().equals(one.getNodeId())) {
                    TreeNode subNode = new TreeNode();
                    subNode.setSelf(subOne);
                    elm.getChildrenList().add(subNode);
                }

            }
            retData.getTreeNode().add(elm);
        }

// TODO: 2024/12/23 手写代码
        retData.setNodeGraphDatabaseList(null);
        retData.setNodeAttributeGraphDatabaseList(null);

        return retData;
    }

    /**
     * D2新增节点标签(公共)[10469]
     * gen by moon at 12/18/2024, 6:46:34 PM
     */
    @Trace(operationName = "D2新增节点标签(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddNodeTagGraphDatabaseComRespDto addNodeTagGraphDatabaseCom(AddNodeTagGraphDatabaseComReqDto reqDto) {


        //步骤0: M2新增节点标签（特殊方法） - addNodeTagGraphDatabase
        //ModelCode: addNodeTagGraphDatabase
        AddNodeTagGraphDatabaseRespDto addNodeTagGraphDatabaseRes = null;
        AddNodeTagGraphDatabaseReqDto addNodeTagGraphDatabaseReq = new AddNodeTagGraphDatabaseReqDto();
        if (reqDto != null) {
            addNodeTagGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037258_1
            addNodeTagGraphDatabaseReq.setTagName(reqDto.getTagName());//SimpleFieldAssign//sourceId:2037259_1
        }

        /*M2新增节点标签（特殊方法）[10459]   */
        Assert.isNull(addNodeTagGraphDatabaseReq.getNodeId(), "D2新增节点标签(公共)-M2新增节点标签（特殊方法）-节点ID（唯一标识）不能为空", false);
        addNodeTagGraphDatabaseRes = nbInterfaceMode.addNodeTagGraphDatabase(addNodeTagGraphDatabaseReq);


        AddNodeTagGraphDatabaseComRespDto retData = new AddNodeTagGraphDatabaseComRespDto();


        return retData;
    }

    /**
     * D2批量增节点标签(公共)[10470]
     * gen by moon at 12/18/2024, 6:46:54 PM
     */
    @Trace(operationName = "D2批量增节点标签(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchAddNodeTagGraphDatabaseComRespDto batchAddNodeTagGraphDatabaseCom(BatchAddNodeTagGraphDatabaseComReqDto reqDto) {


        //步骤0: M2批量增节点标签（特殊方法） - batchAddNodeTagGraphDatabase
        //ModelCode: batchAddNodeTagsGraphDatabase
        BatchAddNodeTagGraphDatabaseRespDto batchAddNodeTagsGraphDatabaseRes = null;
        BatchAddNodeTagGraphDatabaseReqDto batchAddNodeTagsGraphDatabaseReq = new BatchAddNodeTagGraphDatabaseReqDto();
        if (reqDto != null) {
            batchAddNodeTagsGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037264_1
            batchAddNodeTagsGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037265_1
        }

        /*M2批量增节点标签（特殊方法）[10460]   */
        Assert.isNull(batchAddNodeTagsGraphDatabaseReq.getNodeId(), "D2批量增节点标签(公共)-M2批量增节点标签（特殊方法）-节点ID（唯一标识）不能为空", false);
        batchAddNodeTagsGraphDatabaseRes = nbInterfaceMode.batchAddNodeTagGraphDatabase(batchAddNodeTagsGraphDatabaseReq);


        BatchAddNodeTagGraphDatabaseComRespDto retData = new BatchAddNodeTagGraphDatabaseComRespDto();


        return retData;
    }

    /**
     * D2删除节点标签(公共)[10471]
     * gen by moon at 12/18/2024, 6:47:14 PM
     */
    @Trace(operationName = "D2删除节点标签(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteNodeTagGraphDatabaseComRespDto deleteNodeTagGraphDatabaseCom(DeleteNodeTagGraphDatabaseComReqDto reqDto) {


        //步骤0: M2删除节点标签（特殊方法） - deleteNodeTagGraphDatabase
        //ModelCode: deleteNodeGraphDatabase
        DeleteNodeTagGraphDatabaseRespDto deleteNodeGraphDatabaseRes = null;
        DeleteNodeTagGraphDatabaseReqDto deleteNodeGraphDatabaseReq = new DeleteNodeTagGraphDatabaseReqDto();
        if (reqDto != null) {
            deleteNodeGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037270_1
            deleteNodeGraphDatabaseReq.setTagName(reqDto.getTagName());//SimpleFieldAssign//sourceId:2037271_1
        }

        /*M2删除节点标签（特殊方法）[10461]   */
        Assert.isNull(deleteNodeGraphDatabaseReq.getNodeId(), "D2删除节点标签(公共)-M2删除节点标签（特殊方法）-节点ID（唯一标识）不能为空", false);
        deleteNodeGraphDatabaseRes = nbInterfaceMode.deleteNodeTagGraphDatabase(deleteNodeGraphDatabaseReq);


        DeleteNodeTagGraphDatabaseComRespDto retData = new DeleteNodeTagGraphDatabaseComRespDto();


        return retData;
    }

    /**
     * D2批量删节点标签(公共)[10472]
     * gen by moon at 12/18/2024, 6:47:34 PM
     */
    @Trace(operationName = "D2批量删节点标签(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchDeleteNodeTagGraphDatabaseComRespDto batchDeleteNodeTagGraphDatabaseCom(BatchDeleteNodeTagGraphDatabaseComReqDto reqDto) {


        //步骤0: M2批量删节点标签（特殊方法） - batchDeleteNodeTagGraphDatabase
        //ModelCode: deleteNodeTagGraphDatabase
        BatchDeleteNodeTagGraphDatabaseRespDto deleteNodeTagGraphDatabaseRes = null;
        BatchDeleteNodeTagGraphDatabaseReqDto deleteNodeTagGraphDatabaseReq = new BatchDeleteNodeTagGraphDatabaseReqDto();
        if (reqDto != null) {
            deleteNodeTagGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037276_1
            deleteNodeTagGraphDatabaseReq.setNodeTagGraphDatabaseList(reqDto.getNodeTagGraphDatabaseList());//list-field-assign//sourceId:2037277_1
        }

        /*M2批量删节点标签（特殊方法）[10462]   */
        Assert.isNull(deleteNodeTagGraphDatabaseReq.getNodeId(), "D2批量删节点标签(公共)-M2批量删节点标签（特殊方法）-节点ID（唯一标识）不能为空", false);
        deleteNodeTagGraphDatabaseRes = nbInterfaceMode.batchDeleteNodeTagGraphDatabase(deleteNodeTagGraphDatabaseReq);


        BatchDeleteNodeTagGraphDatabaseComRespDto retData = new BatchDeleteNodeTagGraphDatabaseComRespDto();


        return retData;
    }

    /**
     * D2新增节点关系(公共)[10473]
     * gen by moon at 5/8/2025, 8:43:35 PM
     */
    @Trace(operationName = "D2新增节点关系(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddNodeRelationGraphDatabaseComRespDto addNodeRelationGraphDatabaseCom(AddNodeRelationGraphDatabaseComReqDto reqDto) {


        //步骤0: M2新增节点关系（特殊方法） - addNodeRelationGraphDatabase
        //ModelCode: addNodeRelationGraphDatabase
        AddNodeRelationGraphDatabaseRespDto addNodeRelationGraphDatabaseRes = null;
        AddNodeRelationGraphDatabaseReqDto addNodeRelationGraphDatabaseReq = new AddNodeRelationGraphDatabaseReqDto();
        if (reqDto != null) {
            addNodeRelationGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037291_1
            addNodeRelationGraphDatabaseReq.setRelationNodeId(reqDto.getRelationNodeId());//SimpleFieldAssign//sourceId:2037292_1
            addNodeRelationGraphDatabaseReq.setRelationType(reqDto.getRelationType());//SimpleFieldAssign//sourceId:2037296_1
            addNodeRelationGraphDatabaseReq.setRelationDirection(reqDto.getRelationDirection());//SimpleFieldAssign//sourceId:2037297_1
        }
        if (reqDto != null && reqDto.getNodeRelationAttrGraphDatabaseList() != null && !CollectionUtil.isEmpty(reqDto.getNodeRelationAttrGraphDatabaseList())) {
            addNodeRelationGraphDatabaseReq.setNodeRelationAttrGraphDatabaseList(reqDto.getNodeRelationAttrGraphDatabaseList().stream().map(item -> BeanUtil.toBean(item, NodeRelationAttrGraphDatabaseDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037298_1
        }

        /*M2新增节点关系（特殊方法）[10463]   */
        Assert.isNull(addNodeRelationGraphDatabaseReq.getNodeId(), "D2新增节点关系(公共)-M2新增节点关系（特殊方法）-节点ID（唯一标识）不能为空", false);
        Assert.isNull(addNodeRelationGraphDatabaseReq.getRelationNodeId(), "D2新增节点关系(公共)-M2新增节点关系（特殊方法）-关联节点ID（唯一标识）不能为空", false);
        addNodeRelationGraphDatabaseRes = nbInterfaceMode.addNodeRelationGraphDatabase(addNodeRelationGraphDatabaseReq);


        AddNodeRelationGraphDatabaseComRespDto retData = new AddNodeRelationGraphDatabaseComRespDto();


        return retData;
    }

    /**
     * D2删除节点关系(公共)[10474]
     * gen by moon at 12/18/2024, 6:48:21 PM
     */
    @Trace(operationName = "D2删除节点关系(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteNodeRelationGraphDatabaseComRespDto deleteNodeRelationGraphDatabaseCom(DeleteNodeRelationGraphDatabaseComReqDto reqDto) {


        //步骤0: M2删除节点关系（特殊方法） - deleteNodeRelationGraphDatabase
        //ModelCode: deleteNodeRelationGraphDatabase
        DeleteNodeRelationGraphDatabaseRespDto deleteNodeRelationGraphDatabaseRes = null;
        DeleteNodeRelationGraphDatabaseReqDto deleteNodeRelationGraphDatabaseReq = new DeleteNodeRelationGraphDatabaseReqDto();
        if (reqDto != null) {
            deleteNodeRelationGraphDatabaseReq.setNodeId(reqDto.getNodeId());//SimpleFieldAssign//sourceId:2037285_1
            deleteNodeRelationGraphDatabaseReq.setRelationType(reqDto.getRelationType());//SimpleFieldAssign//sourceId:2037286_1
            deleteNodeRelationGraphDatabaseReq.setRelationDirection(reqDto.getRelationDirection());//SimpleFieldAssign//sourceId:2037287_1
        }

        /*M2删除节点关系（特殊方法）[10464]   */
        Assert.isNull(deleteNodeRelationGraphDatabaseReq.getNodeId(), "D2删除节点关系(公共)-M2删除节点关系（特殊方法）-节点ID（唯一标识）不能为空", false);
        deleteNodeRelationGraphDatabaseRes = nbInterfaceMode.deleteNodeRelationGraphDatabase(deleteNodeRelationGraphDatabaseReq);


        DeleteNodeRelationGraphDatabaseComRespDto retData = new DeleteNodeRelationGraphDatabaseComRespDto();


        return retData;
    }

    /**
     * D2执行数据导出excel(公共)[10476]
     * gen by moon at 12/30/2024, 6:11:44 PM
     */
    @Trace(operationName = "D2执行数据导出excel(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExportDatatoExcelComRespDto implementExportDatatoExcelCom(ImplementExportDatatoExcelComReqDto reqDto) {


        //步骤0: M2执行数据导出excel（特殊方法） - implementExportDataToExcel
        //ModelCode: exportDataToExcel
        ImplementExportDataToExcelRespDto exportDataToExcelRes = null;
        ImplementExportDataToExcelReqDto exportDataToExcelReq = new ImplementExportDataToExcelReqDto();
        if (reqDto != null) {
            exportDataToExcelReq.setExportExcelFileName(reqDto.getExportExcelFileName());//SimpleFieldAssign//sourceId:2037366_1
            exportDataToExcelReq.setExportFileFormat(reqDto.getExportFileFormat());//SimpleFieldAssign//sourceId:2037369_1
        }
        if (reqDto != null && reqDto.getExcelHeaderFieldDataList() != null && !CollectionUtil.isEmpty(reqDto.getExcelHeaderFieldDataList())) {
            exportDataToExcelReq.setExcelHeaderFieldDataList(reqDto.getExcelHeaderFieldDataList().stream().map(item -> BeanUtil.toBean(item, ExcelHeaderFieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037361_1
        }
        if (reqDto != null && reqDto.getExportDataList() != null && !CollectionUtil.isEmpty(reqDto.getExportDataList())) {
            exportDataToExcelReq.setExportDataList(reqDto.getExportDataList().stream().map(item -> BeanUtil.toBean(item, ExportDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2037362_1
        }

        /*M2执行数据导出excel（特殊方法）[10475]   */

        exportDataToExcelRes = nbInterfaceMode.implementExportDataToExcel(exportDataToExcelReq);


        ImplementExportDatatoExcelComRespDto retData = new ImplementExportDatatoExcelComRespDto();


        return retData;
    }

    /**
     * D2新增MQ队列数据(公共)[10483]
     * gen by moon at 3/22/2025, 5:13:23 PM
     */
    @Trace(operationName = "D2新增MQ队列数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddMessageQueueDataComRespDto addMessageQueueDataCom(AddMessageQueueDataComReqDto reqDto) {


        //步骤0: M2-新增MQ队列数据（特殊方法） - addMessageQueueData
        //ModelCode: addMqQueueData
        AddMessageQueueDataRespDto addMqQueueDataRes = null;
        AddMessageQueueDataReqDto addMqQueueDataReq = new AddMessageQueueDataReqDto();
        addMqQueueDataReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043179_1
        if (reqDto != null) {
            addMqQueueDataReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039424_1
            addMqQueueDataReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039425_1
        }
        if (reqDto != null && reqDto.getFieldDataList() != null && !CollectionUtil.isEmpty(reqDto.getFieldDataList())) {
            addMqQueueDataReq.setFieldDataList(reqDto.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2039426_1
        }

        /*M2-新增MQ队列数据（特殊方法）[10482] MQ队列分区号目前约定为0，涉及新增、修改、查询，方便以后扩展使用  */
        Assert.isNull(addMqQueueDataReq.getMqQueueName(), "D2新增MQ队列数据(公共)-M2-新增MQ队列数据（特殊方法）-MQ队列名称不能为空", false);
        Assert.isNull(addMqQueueDataReq.getMqPrimaryId(), "D2新增MQ队列数据(公共)-M2-新增MQ队列数据（特殊方法）-MQ队列唯一主键ID不能为空", false);
        Assert.isNull(addMqQueueDataReq.getMqSubNumer(), "D2新增MQ队列数据(公共)-M2-新增MQ队列数据（特殊方法）-MQ子队列序号值不能为空", false);
        addMqQueueDataRes = nbInterfaceMode.addMessageQueueData(addMqQueueDataReq);


        AddMessageQueueDataComRespDto retData = new AddMessageQueueDataComRespDto();


        return retData;
    }

    /**
     * D2执行注册MQ队列(公共)[10485]
     * gen by moon at 3/4/2025, 11:08:36 AM
     */
    @Trace(operationName = "D2执行注册MQ队列(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddMessageQueueComRespDto addMessageQueueCom(AddMessageQueueComReqDto reqDto) {


        //步骤0: M2-执行注册MQ队列（特殊方法） - registerMessageQueue
        //ModelCode: registerMqQueue
        RegisterMessageQueueRespDto registerMqQueueRes = null;
        RegisterMessageQueueReqDto registerMqQueueReq = new RegisterMessageQueueReqDto();
        if (reqDto != null) {
            registerMqQueueReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039434_1
            registerMqQueueReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039435_1
        }

        /*M2-执行注册MQ队列（特殊方法）[10484]   */
        Assert.isNull(registerMqQueueReq.getMqQueueName(), "D2执行注册MQ队列(公共)-M2-执行注册MQ队列（特殊方法）-MQ队列名称不能为空", false);
        Assert.isNull(registerMqQueueReq.getMqPrimaryId(), "D2执行注册MQ队列(公共)-M2-执行注册MQ队列（特殊方法）-MQ队列唯一主键ID不能为空", false);
        registerMqQueueRes = nbInterfaceMode.registerMessageQueue(registerMqQueueReq);


        AddMessageQueueComRespDto retData = new AddMessageQueueComRespDto();


        return retData;
    }

    /**
     * D2修改MQ队列最小值(公共)[10487]
     * gen by moon at 3/22/2025, 5:13:26 PM
     */
    @Trace(operationName = "D2修改MQ队列最小值(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateMessageQueueComRespDto updateMessageQueueCom(UpdateMessageQueueComReqDto reqDto) {


        //步骤0: M2-修改MQ队列最小值（特殊方法） - updateMessageQueue
        //ModelCode: updateCurMqQueueMin
        UpdateMessageQueueRespDto updateCurMqQueueMinRes = null;
        UpdateMessageQueueReqDto updateCurMqQueueMinReq = new UpdateMessageQueueReqDto();
        updateCurMqQueueMinReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043181_1
        if (reqDto != null) {
            updateCurMqQueueMinReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039454_1
            updateCurMqQueueMinReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039455_1
            updateCurMqQueueMinReq.setMqQueueMinimum(reqDto.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2039456_1
        }

        /*M2-修改MQ队列最小值（特殊方法）[10486]   */
        Assert.isNull(updateCurMqQueueMinReq.getMqQueueName(), "D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ队列名称不能为空", false);
        Assert.isNull(updateCurMqQueueMinReq.getMqPrimaryId(), "D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ队列唯一主键ID不能为空", false);
        Assert.isNull(updateCurMqQueueMinReq.getMqQueueMinimum(), "D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ队列最小值不能为空", false);
        Assert.isNull(updateCurMqQueueMinReq.getMqSubNumer(), "D2修改MQ队列最小值(公共)-M2-修改MQ队列最小值（特殊方法）-MQ子队列序号值不能为空", false);
        updateCurMqQueueMinRes = nbInterfaceMode.updateMessageQueue(updateCurMqQueueMinReq);


        UpdateMessageQueueComRespDto retData = new UpdateMessageQueueComRespDto();


        return retData;
    }

    /**
     * D2查询MQ队列数据列表(公共)[10489]
     * gen by moon at 3/22/2025, 5:13:29 PM
     */
    @Trace(operationName = "D2查询MQ队列数据列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryMessageQueueListComRespDto queryMessageQueueListCom(QueryMessageQueueListComReqDto reqDto) {


        QueryMessageQueueDataListRespDto queryMqQueueDataListRes_1 = null;
//步骤0: M2-查询MQ队列数据列表（特殊方法） - queryMessageQueueDataList
        //ModelCode: queryMqQueueDataList
        QueryMessageQueueDataListRespDto queryMqQueueDataListRes = null;
        QueryMessageQueueDataListReqDto queryMqQueueDataListReq = new QueryMessageQueueDataListReqDto();
        queryMqQueueDataListReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043183_1
        if (reqDto != null) {
            queryMqQueueDataListReq.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2040149_1
            queryMqQueueDataListReq.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040150_1
        }
        if (reqDto != null && reqDto.getMessageQueueDataList() != null && !CollectionUtil.isEmpty(reqDto.getMessageQueueDataList())) {
            queryMqQueueDataListReq.setMessageQueueDataList(reqDto.getMessageQueueDataList().stream().map(item -> BeanUtil.toBean(item, MessageQueueDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2039877_1
        }

        /*M2-查询MQ队列数据列表（特殊方法）[10488]   */

        queryMqQueueDataListRes = nbInterfaceMode.queryMessageQueueDataList(queryMqQueueDataListReq);


        queryMqQueueDataListRes_1 = queryMqQueueDataListRes;

        QueryMessageQueueListComRespDto retData = new QueryMessageQueueListComRespDto();
        if (queryMqQueueDataListRes_1 != null) {
            retData.setMqQueueName(queryMqQueueDataListRes_1.getMqQueueName());//SimpleFieldAssign//sourceId:2039466_1
            retData.setMqPrimaryId(queryMqQueueDataListRes_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039467_1
            retData.setMqQueueMinimum(queryMqQueueDataListRes_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2039468_1
            retData.setFieldDataList(queryMqQueueDataListRes_1.getFieldDataList().stream().map(item -> BeanUtil.toBean(item, FieldDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2039469_1
        }


        return retData;
    }

    /**
     * D2遍历查询有数据的MQ队列(公共)[10498]
     * gen by moon at 3/22/2025, 5:13:32 PM
     */
    @Trace(operationName = "D2遍历查询有数据的MQ队列(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryHaveDataMqQueueDetailComRespDto queryHaveDataMqQueueDetailCom(QueryHaveDataMqQueueDetailComReqDto reqDto) {


        QueryHaveDataMqQueueDetailRespDto queryHaveDataMqQueueRes_1 = null;
//步骤0: M2-遍历查询有数据的MQ队列 - queryHaveDataMqQueueDetail
        //ModelCode: queryHaveDataMqQueue
        QueryHaveDataMqQueueDetailRespDto queryHaveDataMqQueueRes = null;
        QueryHaveDataMqQueueDetailReqDto queryHaveDataMqQueueReq = new QueryHaveDataMqQueueDetailReqDto();
        queryHaveDataMqQueueReq.setMqSubNumer(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:2043185_1

        /*M2-遍历查询有数据的MQ队列[10497]   */
        Assert.isNull(queryHaveDataMqQueueReq.getMqSubNumer(), "D2遍历查询有数据的MQ队列(公共)-M2-遍历查询有数据的MQ队列-MQ子队列序号值不能为空", false);
        queryHaveDataMqQueueRes = nbInterfaceMode.queryHaveDataMqQueueDetail(queryHaveDataMqQueueReq);


        queryHaveDataMqQueueRes_1 = queryHaveDataMqQueueRes;

        QueryHaveDataMqQueueDetailComRespDto retData = new QueryHaveDataMqQueueDetailComRespDto();
        if (queryHaveDataMqQueueRes_1 != null) {
            retData.setMqQueueName(queryHaveDataMqQueueRes_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040145_1
            retData.setMqPrimaryId(queryHaveDataMqQueueRes_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040146_1
        }


        return retData;
    }

    /**
     * D2执行名称副本处理(公共)[10540]
     * gen by moon at 6/2/2025, 12:03:41 PM
     */
    @Trace(operationName = "D2执行名称副本处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementNameCopyHandleComRespDto implementNameCopyHandleCom(ImplementNameCopyHandleComReqDto reqDto) {


        ImplementNameCopyHandleRespDto nameCopyRes_1 = null;
//步骤0: M2执行名称副本处理（特殊方法） - implementNameCopyHandle
        //ModelCode: nameCopy
        ImplementNameCopyHandleRespDto nameCopyRes = null;
        ImplementNameCopyHandleReqDto nameCopyReq = new ImplementNameCopyHandleReqDto();
        if (reqDto != null) {
            nameCopyReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:2047928_1
            nameCopyReq.setCopyName(reqDto.getCopyName());//SimpleFieldAssign//sourceId:2047929_1
        }
        if (reqDto != null && reqDto.getComDatasList() != null && !CollectionUtil.isEmpty(reqDto.getComDatasList())) {
            nameCopyReq.setComDatasList(reqDto.getComDatasList().stream().map(item -> BeanUtil.toBean(item, ComDatasDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2047927_1
        }

        /*M2执行名称副本处理（特殊方法）[10539]   */
        Assert.isNull(nameCopyReq.getCustomField(), "D2执行名称副本处理(公共)-M2执行名称副本处理（特殊方法）-自定义字段不能为空", false);
        nameCopyRes = nbInterfaceMode.implementNameCopyHandle(nameCopyReq);


        nameCopyRes_1 = nameCopyRes;

        ImplementNameCopyHandleComRespDto retData = new ImplementNameCopyHandleComRespDto();
        if (nameCopyRes_1 != null) {
            retData.setNameCopyValue(nameCopyRes_1.getNameCopyValue());//SimpleFieldAssign//sourceId:2047934_1
        }


        return retData;
    }


    //
}
